idp.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _IDP_HPP
#define _IDP_HPP
 
#include <fpro.h>
#include <ieee.h>
#include <nalt.hpp>
#include <segment.hpp>
#include <funcs.hpp>
#include <ua.hpp>
#include <bitrange.hpp>
#include <config.hpp>

 
typedef int help_t; 
 
struct outctx_t;
struct regval_t;
struct stkpnts_t;
struct simd_info_t;
struct reg_accesses_t;
struct call_stack_t;
struct stkarg_area_info_t;
struct reg_finder_t;
class merge_data_t;
class idasgn_t;

 
#define IDP_INTERFACE_VERSION 900
 
//-----------------------------------------------------------------------
struct bytes_t
{
  uchar len;
  const uchar *bytes;
};
 
//-------------------------------------------------------------------------
#define CF_STOP 0x00001   
#define CF_CALL 0x00002   
#define CF_CHG1 0x00004   
#define CF_CHG2 0x00008   
#define CF_CHG3 0x00010   
#define CF_CHG4 0x00020   
#define CF_CHG5 0x00040   
#define CF_CHG6 0x00080   
#define CF_USE1 0x00100   
#define CF_USE2 0x00200   
#define CF_USE3 0x00400   
#define CF_USE4 0x00800   
#define CF_USE5 0x01000   
#define CF_USE6 0x02000   
#define CF_JUMP 0x04000   
#define CF_SHFT 0x08000   
#define CF_HLL  0x10000   
#define CF_CHG7 0x020000  
#define CF_CHG8 0x040000  
#define CF_USE7 0x080000  
#define CF_USE8 0x100000  
 
//-----------------------------------------------------------------------
struct instruc_t
{
  const char *name;       
  uint32 feature;         
};
 

 
inline THREAD_SAFE bool has_cf_chg(uint32 feature, uint opnum)
{
  static const int bits[] =
  {
    CF_CHG1, CF_CHG2, CF_CHG3, CF_CHG4,
    CF_CHG5, CF_CHG6, CF_CHG7, CF_CHG8,
  };
  CASSERT(qnumber(bits) == UA_MAXOP);
  return opnum < UA_MAXOP && (feature & bits[opnum]) != 0;
}
 

 
inline THREAD_SAFE bool has_cf_use(uint32 feature, uint opnum)
{
  static const int bits[] =
  {
    CF_USE1, CF_USE2, CF_USE3, CF_USE4,
    CF_USE5, CF_USE6, CF_USE7, CF_USE8,
  };
  CASSERT(qnumber(bits) == UA_MAXOP);
  return opnum < UA_MAXOP && (feature & bits[opnum]) != 0;
}
 

 
idaman bool ida_export has_insn_feature(uint16 icode, uint32 bit);
 
 

 
idaman bool ida_export is_call_insn(const insn_t &insn);
 


#define IRI_EXTENDED        0x00 
#define IRI_RET_LITERALLY   0x01 
#define IRI_SKIP_RETTARGET  0x02 
#define IRI_STRICT          (IRI_RET_LITERALLY|IRI_SKIP_RETTARGET)
idaman bool ida_export is_ret_insn(const insn_t &insn, uchar flags=IRI_STRICT);
 

 
idaman bool ida_export is_indirect_jump_insn(const insn_t &insn);
 

 
idaman bool ida_export is_basic_block_end(const insn_t &insn, bool call_insn_stops_block);
 
 
//=====================================================================
struct asm_t
{
  uint32 flag;                          
#define AS_OFFST      0x00000001        
#define AS_COLON      0x00000002        
#define AS_UDATA      0x00000004        
 
#define AS_2CHRE      0x00000008        
#define AS_NCHRE      0x00000010        
#define AS_N2CHR      0x00000020        
 
                                        // String literals:
#define AS_1TEXT      0x00000040        
#define AS_NHIAS      0x00000080        
#define AS_NCMAS      0x00000100        
 
#define AS_HEXFM      0x00000E00        
#define ASH_HEXF0     0x00000000        
#define ASH_HEXF1     0x00000200        
#define ASH_HEXF2     0x00000400        
#define ASH_HEXF3     0x00000600        
#define ASH_HEXF4     0x00000800        
#define ASH_HEXF5     0x00000A00        
#define AS_DECFM      0x00003000        
#define ASD_DECF0     0x00000000        
#define ASD_DECF1     0x00001000        
#define ASD_DECF2     0x00002000        
#define ASD_DECF3     0x00003000        
#define AS_OCTFM      0x0001C000        
#define ASO_OCTF0     0x00000000        
#define ASO_OCTF1     0x00004000        
#define ASO_OCTF2     0x00008000        
#define ASO_OCTF3     0x0000C000        
#define ASO_OCTF4     0x00010000        
#define ASO_OCTF5     0x00014000        
#define ASO_OCTF6     0x00018000        
#define ASO_OCTF7     0x0001C000        
#define AS_BINFM      0x000E0000        
#define ASB_BINF0     0x00000000        
#define ASB_BINF1     0x00020000        
#define ASB_BINF2     0x00040000        
#define ASB_BINF3     0x00060000        
#define ASB_BINF4     0x00080000        
#define ASB_BINF5     0x000A0000        
 
#define AS_UNEQU      0x00100000        
#define AS_ONEDUP     0x00200000        
#define AS_NOXRF      0x00400000        
#define AS_XTRNTYPE   0x00800000        
#define AS_RELSUP     0x01000000        
#define AS_LALIGN     0x02000000        
#define AS_NOCODECLN  0x04000000        
#define AS_NOSPACE    0x10000000        
#define AS_ALIGN2     0x20000000        
#define AS_ASCIIC     0x40000000        
#define AS_ASCIIZ     0x80000000        
  uint16 uflag;                         
  const char *name;                     
  help_t help;                          
  const char *const *header;            
  const char *origin;                   
  const char *end;                      
  const char *cmnt;                     
  char ascsep;                          
  char accsep;                          
  const char *esccodes;                 
 
  // Data representation (db,dw,...):
  const char *a_ascii;                  
  const char *a_byte;                   
  const char *a_word;                   
  const char *a_dword;                  
  const char *a_qword;                  
  const char *a_oword;                  
  const char *a_float;                  
  const char *a_double;                 
  const char *a_tbyte;                  
  const char *a_packreal;               
  const char *a_dups;                   
  const char *a_bss;                    
  const char *a_equ;                    
  const char *a_seg;                    
 
  const char *a_curip;                  

  void (idaapi *out_func_header)(outctx_t &ctx, func_t *);

  void (idaapi *out_func_footer)(outctx_t &ctx, func_t *);
 
  const char *a_public;                 
  const char *a_weak;                   
  const char *a_extrn;                  
  const char *a_comdef;                 

  ssize_t (idaapi *get_type_name)(
        qstring *buf,
        flags64_t flag,
        ea_t ea_or_id);
 
  const char *a_align;                  
 
  char lbrace;                          
  char rbrace;                          
 
  const char *a_mod;                    
  const char *a_band;                   
  const char *a_bor;                    
  const char *a_xor;                    
  const char *a_bnot;                   
  const char *a_shl;                    
  const char *a_shr;                    
  const char *a_sizeof_fmt;             
 
  uint32 flag2;                         
#define AS2_BRACE     0x00000001        
#define AS2_STRINV    0x00000002        
#define AS2_BYTE1CHAR 0x00000004        
#define AS2_IDEALDSCR 0x00000008        
#define AS2_TERSESTR  0x00000010        
#define AS2_COLONSUF  0x00000020        
#define AS2_YWORD     0x00000040        
#define AS2_ZWORD     0x00000080        
 
  const char *cmnt2;                    
  const char *low8;                     
  const char *high8;                    
  const char *low16;                    
  const char *high16;                   
  const char *a_include_fmt;            
  const char *a_vstruc_fmt;             
  const char *a_rva;                    
  const char *a_yword;                  
  const char *a_zword;                  
};
#ifndef __X86__
CASSERT(sizeof(asm_t) == 416);
#else
CASSERT(sizeof(asm_t) == 212);
#endif
 
// forward declarations for notification helpers
struct proc_def_t;
struct elf_loader_t;
class reader_t;
struct extlang_t;
class qflow_chart_t;
struct libfunc_t;
struct fixup_data_t;
struct idd_opinfo_t;
class argloc_t;
struct func_type_data_t;
struct regobjs_t;
class callregs_t;
struct funcarg_t;
 
//--------------------------------------------------------------------------
struct event_listener_t;

idaman bool ida_export hook_event_listener(
        hook_type_t hook_type,
        event_listener_t *cb,
        const void *owner,
        int hkcb_flags=0);
#define HKCB_GLOBAL  0x0001 

idaman bool ida_export unhook_event_listener(
        hook_type_t hook_type,
        event_listener_t *cb);

idaman void ida_export remove_event_listener(event_listener_t *cb);
 
struct event_listener_t
{
  size_t listener_flags = 0; // reserved
  virtual ssize_t idaapi on_event(ssize_t code, va_list va) = 0;
  virtual ~event_listener_t() { remove_event_listener(this); }
};

#define DECLARE_LISTENER(listener_type, ctx_type, ctx_name)             \
  struct listener_type : public event_listener_t                        \
  {                                                                     \
    ctx_type &ctx_name;                                                 \
    listener_type(ctx_type &_ctx) : ctx_name(_ctx) {}                   \
    virtual ssize_t idaapi on_event(ssize_t code, va_list va) override; \
  }
 
//-------------------------------------------------------------------------
#define PLFM_386        0         
#define PLFM_Z80        1         
#define PLFM_I860       2         
#define PLFM_8051       3         
#define PLFM_TMS        4         
#define PLFM_6502       5         
#define PLFM_PDP        6         
#define PLFM_68K        7         
#define PLFM_JAVA       8         
#define PLFM_6800       9         
#define PLFM_ST7        10        
#define PLFM_MC6812     11        
#define PLFM_MIPS       12        
#define PLFM_ARM        13        
#define PLFM_TMSC6      14        
#define PLFM_PPC        15        
#define PLFM_80196      16        
#define PLFM_Z8         17        
#define PLFM_SH         18        
#define PLFM_NET        19        
#define PLFM_AVR        20        
#define PLFM_H8         21        
#define PLFM_PIC        22        
#define PLFM_SPARC      23        
#define PLFM_ALPHA      24        
#define PLFM_HPPA       25        
#define PLFM_H8500      26        
#define PLFM_TRICORE    27        
#define PLFM_DSP56K     28        
#define PLFM_C166       29        
#define PLFM_ST20       30        
#define PLFM_IA64       31        
#define PLFM_I960       32        
#define PLFM_F2MC       33        
#define PLFM_TMS320C54  34        
#define PLFM_TMS320C55  35        
#define PLFM_TRIMEDIA   36        
#define PLFM_M32R       37        
#define PLFM_NEC_78K0   38        
#define PLFM_NEC_78K0S  39        
#define PLFM_M740       40        
#define PLFM_M7700      41        
#define PLFM_ST9        42        
#define PLFM_FR         43        
#define PLFM_MC6816     44        
#define PLFM_M7900      45        
#define PLFM_TMS320C3   46        
#define PLFM_KR1878     47        
#define PLFM_AD218X     48        
#define PLFM_OAKDSP     49        
#define PLFM_TLCS900    50        
#define PLFM_C39        51        
#define PLFM_CR16       52        
#define PLFM_MN102L00   53        
#define PLFM_TMS320C1X  54        
#define PLFM_NEC_V850X  55        
#define PLFM_SCR_ADPT   56        
#define PLFM_EBC        57        
#define PLFM_MSP430     58        
#define PLFM_SPU        59        
#define PLFM_DALVIK     60        
#define PLFM_65C816     61        
#define PLFM_M16C       62        
#define PLFM_ARC        63        
#define PLFM_UNSP       64        
#define PLFM_TMS320C28  65        
#define PLFM_DSP96K     66        
#define PLFM_SPC700     67        
#define PLFM_AD2106X    68        
#define PLFM_PIC16      69        
#define PLFM_S390       70        
#define PLFM_XTENSA     71        
#define PLFM_RISCV      72        
#define PLFM_RL78       73        
#define PLFM_RX         74        
#define PLFM_WASM       75        
 
//-------------------------------------------------------------------------
#define PR_SEGS       0x000001    
#define PR_USE32      0x000002    
#define PR_DEFSEG32   0x000004    
#define PR_RNAMESOK   0x000008    
//#define PR_DB2CSEG    0x0010    // .byte directive in code segments
//                                // should define even number of bytes
//                                // (used by AVR processor)
#define PR_ADJSEGS    0x000020    
#define PR_DEFNUM     0x0000C0    
#define PRN_HEX       0x000000    
#define PRN_OCT       0x000040    
#define PRN_DEC       0x000080    
#define PRN_BIN       0x0000C0    
#define PR_WORD_INS   0x000100    
#define PR_NOCHANGE   0x000200    
#define PR_ASSEMBLE   0x000400    
#define PR_ALIGN      0x000800    
#define PR_TYPEINFO   0x001000    
#define PR_USE64      0x002000    
#define PR_SGROTHER   0x004000    
#define PR_STACK_UP   0x008000    
#define PR_BINMEM     0x010000    
#define PR_SEGTRANS   0x020000    
#define PR_CHK_XREF   0x040000    
#define PR_NO_SEGMOVE 0x080000    
//#define PR_FULL_HIFXP 0x100000  // ::REF_VHIGH operand value contains full operand
//                                // (not only the high bits) Meaningful if \ph{high_fixup_bits}
#define PR_USE_ARG_TYPES 0x200000 
#define PR_SCALE_STKVARS 0x400000 
#define PR_DELAYED    0x800000    
#define PR_ALIGN_INSN 0x1000000   
#define PR_PURGING    0x2000000   
#define PR_CNDINSNS   0x4000000   
#define PR_USE_TBYTE  0x8000000   
#define PR_DEFSEG64  0x10000000   
#define PR_OUTER     0x20000000   
 
//-------------------------------------------------------------------------
#define PR2_MAPPINGS   0x000001   
#define PR2_IDP_OPTS   0x000002   
#define PR2_CODE16_BIT 0x000008   
#define PR2_MACRO       0x000010  
#define PR2_USE_CALCREL 0x000020  
#define PR2_REL_BITS    0x000040  
#define PR2_FORCE_16BIT 0x000080  
 
//-------------------------------------------------------------------------
#define OP_FP_BASED  0x00000000 
#define OP_SP_BASED  0x00000001 
#define OP_SP_ADD    0x00000000 
#define OP_SP_SUB    0x00000002 
 
//-------------------------------------------------------------------------
#define CUSTOM_INSN_ITYPE 0x8000
 
//-------------------------------------------------------------------------
#define REG_SPOIL 0x80000000
 
//=====================================================================
struct processor_t
{
  int32 version;                  
  int32 id;                       
  uint32 flag;                    
  uint32 flag2;                   
 
  bool has_idp_opts(void) const { return (flag2 & PR2_IDP_OPTS)       != 0; }  
  bool has_segregs(void) const  { return (flag & PR_SEGS)             != 0; }  
  bool use32(void) const        { return (flag & (PR_USE64|PR_USE32)) != 0; }  
  bool use64(void) const        { return (flag & PR_USE64)            != 0; }  
  bool ti(void) const           { return (flag & PR_TYPEINFO)         != 0; }  
  bool stkup(void) const        { return (flag & PR_STACK_UP)         != 0; }  
  bool use_tbyte(void) const    { return (flag & PR_USE_TBYTE)        != 0; }  
  bool use_mappings(void) const { return (flag2 & PR2_MAPPINGS)       != 0; }  
  bool has_code16_bit(void) const { return (flag2 & PR2_CODE16_BIT)   != 0; }  
  bool supports_macros(void) const { return (flag2 & PR2_MACRO)       != 0; }  
  bool supports_calcrel(void) const { return (flag2 & PR2_USE_CALCREL) != 0; } 
  bool calcrel_in_bits(void)  const { return (flag2 & PR2_REL_BITS)    != 0; } 

 
  int get_default_segm_bitness(bool is_64bit_app) const
  {
    return is_64bit_app && (flag & PR_DEFSEG64) != 0 ? 2 : (flag & PR_DEFSEG32) != 0;
  }
 
  int32 cnbits;                   
  int32 dnbits;                   

  int cbsize(void) { return (cnbits+7)/8; }  
  int dbsize(void) { return (dnbits+7)/8; }  

  const char *const *psnames;     
  const char *const *plnames;     
 
  inline int get_proc_index();  
 
  const asm_t *const *assemblers; 
 
  typedef const regval_t &(idaapi regval_getter_t)(
        const char *name,
        const regval_t *regvalues);
 
  //<hookgen IDP>

  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_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,           
 
    // the following 5 events are very low level
    // take care of possible recursion
    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_def,          
 
    ev_is_addr_insn,            
 
    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,       
 
    // END OF DEBUGGER CALLBACKS
 
    // START OF TYPEINFO CALLBACKS TODO: get this into doxygen output
    // The codes below will be called only if #PR_TYPEINFO is set.
    // Please note that some codes are optional but the more codes
    // are implemented, the better the analysis.
 
    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_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,
 
    // END OF TYPEINFO CALLBACKS
 
    ev_loader=3000,             
  };

  hook_cb_t *_notify;
  static ssize_t notify(event_t event_code, ...)
  {
    va_list va;
    va_start(va, event_code);
    ssize_t code = invoke_callbacks(HT_IDP, event_code, va);
    va_end(va);
    return code;
  }
 
  // Notification helpers, should be used instead of direct ph.notify(...) calls
  inline static ssize_t init(const char *idp_modname);
  inline static ssize_t term();
  inline static ssize_t newprc(int pnum, bool keep_cfg);
  inline static ssize_t newasm(int asmnum);
  inline static ssize_t asm_installed(int asmnum);
  inline static ssize_t newfile(const char *fname);
  inline static ssize_t oldfile(const char *fname);
  inline static ssize_t newbinary(const char *filename, qoff64_t fileoff, ea_t basepara, ea_t binoff, uint64 nbytes);
  inline static ssize_t endbinary(bool ok);
  inline static ssize_t creating_segm(segment_t *seg);
  inline static ssize_t assemble(uchar *_bin, ea_t ea, ea_t cs, ea_t ip, bool _use32, const char *line);
  inline static ssize_t ana_insn(insn_t *out);
  inline static ssize_t emu_insn(const insn_t &insn);
  inline static ssize_t out_header(outctx_t &ctx);
  inline static ssize_t out_footer(outctx_t &ctx);
  inline static ssize_t out_segstart(outctx_t &ctx, segment_t *seg);
  inline static ssize_t out_segend(outctx_t &ctx, segment_t *seg);
  inline static ssize_t out_assumes(outctx_t &ctx);
  inline static ssize_t out_insn(outctx_t &ctx);
  inline static ssize_t out_mnem(outctx_t &ctx);
  inline static ssize_t out_operand(outctx_t &ctx, const op_t &op);
  inline static ssize_t out_data(outctx_t &ctx, bool analyze_only);
  inline static ssize_t out_label(outctx_t &ctx, const char *colored_name);
  inline static ssize_t out_special_item(outctx_t &ctx, uchar segtype);
  inline static ssize_t gen_stkvar_def(outctx_t &ctx, const struct udm_t *mptr, sval_t v, tid_t tid);
  inline static ssize_t gen_regvar_def(outctx_t &ctx, regvar_t *v);
  inline static ssize_t gen_src_file_lnnum(outctx_t &ctx, const char *file, size_t lnnum);
  inline static ssize_t rename(ea_t ea, const char *new_name, int flags);
  inline static ssize_t may_show_sreg(ea_t current_ea);
  inline static ssize_t coagulate(ea_t start_ea);
  inline static void auto_queue_empty(/*atype_t*/ int type);
 
  inline static ssize_t func_bounds(int *possible_return_code, func_t *pfn, ea_t max_func_end_ea);
  inline static ssize_t may_be_func(const insn_t &insn, int state);
  inline static ssize_t is_sane_insn(const insn_t &insn, int no_crefs);
  inline static ssize_t cmp_operands(const op_t &op1, const op_t &op2);
  inline static ssize_t is_jump_func(func_t *pfn, ea_t *jump_target, ea_t *func_pointer);
  inline static ssize_t is_basic_block_end(const insn_t &insn, bool call_insn_stops_block);
  inline static ssize_t getreg(uval_t *rv, int regnum);
  inline static ssize_t undefine(ea_t ea);
  inline static ssize_t moving_segm(segment_t *seg, ea_t to, int flags);
  inline static ssize_t is_sp_based(const insn_t &insn, const op_t &x);
  inline static ssize_t is_far_jump(int icode);
  inline static ssize_t is_call_insn(const insn_t &insn);
  inline static ssize_t is_ret_insn(const insn_t &insn, uchar iri_flags);
  inline static ssize_t is_align_insn(ea_t ea);
  inline static ssize_t is_addr_insn(int *type, const insn_t &insn);
  inline static ssize_t can_have_type(const op_t &op);
  inline static ssize_t get_stkvar_scale_factor();
  inline static ssize_t demangle_name(int32 *res, qstring *out, const char *name, uint32 disable_mask, /*demreq_type_t*/ int demreq);
  inline static ssize_t create_flat_group(ea_t image_base, int bitness, sel_t dataseg_sel);
  inline static ssize_t is_alloca_probe(ea_t ea);
  inline static ssize_t get_reg_name(qstring *buf, int reg, size_t width, int reghi);
  inline static ssize_t gen_asm_or_lst(bool starting, FILE *fp, bool is_asm, int flags, /*html_line_cb_t ** */ void *outline);
  inline static ssize_t gen_map_file(int *nlines, FILE *fp);
  inline static ssize_t get_autocmt(qstring *buf, const insn_t &insn);
  inline 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);
  inline static ssize_t is_indirect_jump(const insn_t &insn);
  inline static ssize_t verify_noreturn(func_t *pfn);
  inline static ssize_t verify_sp(func_t *pfn);
  inline static ssize_t create_func_frame(func_t *pfn);
  inline static ssize_t get_frame_retsize(int *retsize, const func_t *pfn);
  inline static ssize_t analyze_prolog(ea_t fct_ea);
  inline static ssize_t calc_spdelta(sval_t *spdelta, const insn_t &ins);
  inline static ssize_t calcrel(bytevec_t *out_relbits, size_t *out_consumed, ea_t ea);
  inline static ssize_t get_reg_accesses(reg_accesses_t *accvec, const insn_t &insn, int flags);
  inline static ssize_t is_control_flow_guard(int *p_reg, const insn_t *insn);
  inline static ssize_t find_reg_value(uval_t *out, const insn_t &insn, int reg);
  inline static ssize_t find_op_value(uval_t *out, const insn_t &insn, int op);
  inline 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);
  inline static ssize_t extract_address(ea_t *out_ea, ea_t screen_ea, const char *string, size_t x);
  inline static ssize_t str2reg(const char *regname);
  inline static ssize_t is_switch(switch_info_t *si, const insn_t &insn);
  inline static ssize_t create_switch_xrefs(ea_t jumpea, const switch_info_t &si);
  inline static ssize_t calc_switch_cases(/*casevec_t * */void *casevec, eavec_t *targets, ea_t insn_ea, const switch_info_t &si);
  inline static ssize_t get_bg_color(bgcolor_t *color, ea_t ea);
  inline static ssize_t validate_flirt_func(ea_t start_ea, const char *funcname);
  inline static ssize_t get_operand_string(qstring *buf, const insn_t &insn, int opnum);
  inline static ssize_t add_cref(ea_t from, ea_t to, cref_t type);
  inline static ssize_t add_dref(ea_t from, ea_t to, dref_t type);
  inline static ssize_t del_cref(ea_t from, ea_t to, bool expand);
  inline static ssize_t del_dref(ea_t from, ea_t to);
  inline static ssize_t coagulate_dref(ea_t from, ea_t to, bool may_define, ea_t *code_ea);
  inline static const char *set_idp_options(const char *keyword, int vtype, const void *value, bool idb_loaded = true);
  inline static ssize_t set_proc_options(const char *options, int confidence);
  inline static ssize_t adjust_libfunc_ea(const idasgn_t &sig, const libfunc_t &libfun, ea_t *ea);
  inline static fpvalue_error_t realcvt(void *m, fpvalue_t *e, uint16 swt);
  inline bool delay_slot_insn(ea_t *ea, bool *bexec, bool *fexec);
  inline static ssize_t adjust_refinfo(refinfo_t *ri, ea_t ea, int n, const fixup_data_t &fd);
  inline static ssize_t is_cond_insn(const insn_t &insn);
  inline static ssize_t set_code16_mode(ea_t ea, bool code16 = true);
  inline static bool get_code16_mode(ea_t ea);
  inline static ssize_t next_exec_insn(ea_t *target, ea_t ea, int tid, regval_getter_t *_getreg, const regval_t &regvalues);
  inline static ssize_t calc_step_over(ea_t *target, ea_t ip);
  inline static ssize_t get_macro_insn_head(ea_t *head, ea_t ip);
  inline static ssize_t get_dbr_opnum(int *opnum, const insn_t &insn);
  inline static ssize_t insn_reads_tbit(const insn_t &insn, regval_getter_t *_getreg, const regval_t &regvalues);
  inline 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);
  inline static ssize_t calc_next_eas(eavec_t *res, const insn_t &insn, bool over);
  inline static ssize_t clean_tbit(ea_t ea, regval_getter_t *_getreg, const regval_t &regvalues);
  inline static const char *get_reg_info(const char *regname, bitrange_t *bitrange);
  inline static ssize_t update_call_stack(call_stack_t *stack, int tid, regval_getter_t *_getreg, const regval_t &regvalues);
  inline static ssize_t setup_til();
  inline static ssize_t max_ptr_size();
  inline static ssize_t calc_cdecl_purged_bytes(ea_t ea);
  inline static ssize_t equal_reglocs(const argloc_t &a1, const argloc_t &a2);
  inline static ssize_t _decorate_name(qstring *outbuf, const char *name, bool mangle, callcnv_t cc, const tinfo_t &type);
  inline static ssize_t _calc_retloc(argloc_t *retloc, const tinfo_t &rettype, callcnv_t cc);
  inline static ssize_t _calc_varglocs(func_type_data_t *ftd, regobjs_t *regs, relobj_t *stkargs, int nfixed);
  inline static ssize_t _calc_arglocs(func_type_data_t *fti);
  inline static ssize_t use_stkarg_type(ea_t ea, const funcarg_t &arg);
  inline static ssize_t use_regarg_type(int *idx, ea_t ea, /*const funcargvec_t * */void *rargs);
  inline static ssize_t use_arg_types(ea_t ea, func_type_data_t *fti, /*funcargvec_t * */void *rargs);
  inline static ssize_t calc_purged_bytes(int *p_purged_bytes, const func_type_data_t &fti);
  inline static ssize_t get_cc_regs(callregs_t *regs, callcnv_t cc);
  inline static ssize_t get_simd_types(/*simd_info_vec_t * */void *out, const simd_info_t *simd_attrs, const argloc_t *argloc, bool create_tifs);
  inline static ssize_t arg_addrs_ready(ea_t caller, int n, const tinfo_t &tif, ea_t *addrs);
  inline static ssize_t adjust_argloc(argloc_t *argloc, const tinfo_t *type, int size);
  inline static ssize_t lower_func_type(intvec_t *argnums, func_type_data_t *fti);
  inline static ssize_t get_abi_info(qstrvec_t *abi_names, qstrvec_t *abi_opts, comp_t comp);
  inline static ssize_t arch_changed();
  inline static ssize_t create_merge_handlers(merge_data_t *md);
  inline ssize_t privrange_changed(const range_t &old_privrange, adiff_t delta, qstring *errbuf=nullptr);
  inline ssize_t cvt64_supval(nodeidx_t node, uchar tag, nodeidx_t idx, const uchar *data, size_t datlen, qstring *errbuf = nullptr);
  inline ssize_t cvt64_hashval(nodeidx_t node, uchar tag, const char *name, const uchar *data, size_t datlen, qstring *errbuf = nullptr);
  inline static reg_finder_t *get_regfinder();

  int get_stkvar_scale(void)
    {
      if ( (flag & PR_SCALE_STKVARS) == 0 )
        return 1;
      int scale = notify(ev_get_stkvar_scale_factor);
      if ( scale == 0 )
        error("Request ph.get_stkvar_scale_factor should be implemented");
      else if ( scale <= 0 )
        error("Invalid return code from ph.get_stkvar_scale_factor request");
      return scale;
    }
 
  //  Processor register information:
  const char *const *reg_names;         
  int32 regs_num;                       

  int32 reg_first_sreg;                 
  int32 reg_last_sreg;                  
  int32 segreg_size;                    

  int32 reg_code_sreg;                  
  int32 reg_data_sreg;                  
 

  const bytes_t *codestart;             
  const bytes_t *retcodes;              

  int32 instruc_start;                  
  int32 instruc_end;                    

  bool is_canon_insn(uint16 itype) const { return itype >= instruc_start && itype < instruc_end; }
 
  const instruc_t *instruc;             

  const char *get_canon_mnem(uint16 itype) const
  {
    return is_canon_insn(itype) ? instruc[itype-instruc_start].name : nullptr;
  }

  uint32 get_canon_feature(uint16 itype) const
  {
    return is_canon_insn(itype) ? instruc[itype-instruc_start].feature : 0;
  }


  size_t tbyte_size;

  char real_width[4];

  int32 icode_return;

  void *unused_slot;
 
  inline void ensure_processor(void);
  inline size_t sizeof_ldbl() const;
  inline bool is_funcarg_off(const func_t *pfn, uval_t frameoff) const;
  inline sval_t lvar_off(const func_t *pfn, uval_t frameoff) const;
  inline bool is_lumina_usable() const;
};
#ifndef __X86__
CASSERT(sizeof(processor_t) == 144);
#else
CASSERT(sizeof(processor_t) == 104);
#endif
 
// The following two structures contain information about the current
// processor and assembler.
 
idaman processor_t *ida_export get_ph();
#define PH (*get_ph())
idaman asm_t *ida_export get_ash();
#define ASH (*get_ash())
idaman ea_helper_t *ida_export get_eah();
#define EAH (*get_eah())

typedef void *hexdsp_t(int code, ...);
idaman hexdsp_t *ida_export get_hexdsp();
#ifndef HEXDSP
  #define HEXDSP get_hexdsp()
#endif
 
 
#ifndef SWIG
// ignore_micro manager: can be used in modules/plugins as a base class
struct ignore_micro_t
{
  //--------------------------------------------------------------------------
  netnode ignore_micro;
 
#define IM_NONE   0     // regular instruction
#define IM_PROLOG 1     // prolog instruction
#define IM_EPILOG 2     // epilog instruction
#define IM_SWITCH 3     // switch instruction (the indirect jump should not be marked)
 
  inline void init_ignore_micro(void)                  { ignore_micro.create("$ ignore micro"); }
  inline void term_ignore_micro(void)                  { ignore_micro = BADNODE; }
  inline char get_ignore_micro(ea_t ea) const          { return ignore_micro.charval_ea(ea, 0); }
  inline void set_ignore_micro(ea_t ea, uchar im_type) { ignore_micro.charset_ea(ea, im_type, 0); }
  inline void clr_ignore_micro(ea_t ea)                { ignore_micro.chardel_ea(ea, 0); }
  inline ea_t next_marked_insn(ea_t ea)                { return node2ea(ignore_micro.charnext(ea2node(ea), 0)); }
  inline void mark_prolog_insn(ea_t ea)                { set_ignore_micro(ea, IM_PROLOG); }
  inline void mark_epilog_insn(ea_t ea)                { set_ignore_micro(ea, IM_EPILOG); }
  inline void mark_switch_insn(ea_t ea)                { set_ignore_micro(ea, IM_SWITCH); }
  inline bool is_prolog_insn(ea_t ea) const            { return get_ignore_micro(ea) == IM_PROLOG; }
  inline bool is_epilog_insn(ea_t ea) const            { return get_ignore_micro(ea) == IM_EPILOG; }
  inline bool is_switch_insn(ea_t ea) const            { return get_ignore_micro(ea) == IM_SWITCH; }
  inline bool should_ignore_micro(ea_t ea) const       { return get_ignore_micro(ea) != IM_NONE; }
};
#endif // SWIG
 
struct modctx_t
{
  processor_t &ph;
  asm_t &ash;
  ea_helper_t &_eah;
  size_t reserved[8] = { 0 };
  modctx_t() : ph(PH), ash(ASH), _eah(EAH) {}
#ifndef SWIG
  DEFINE_EA_HELPER_FUNCS(_eah)
#endif
  // this class is freed by IDA kernel on unload so must be allocated by it
  DEFINE_MEMORY_ALLOCATION_FUNCS()
};
 
// Each processor module subclasses this class and reacts to HT_IDP events
struct procmod_t : public modctx_t, public event_listener_t, public ignore_micro_t
{
  size_t procmod_flags = 0;
 
  procmod_t() {}
  procmod_t(const procmod_t &) = delete;

  const op_t *make_op_reg(op_t *op, int reg, int8 dtype = -1) const
  {
    op->type = o_reg;
    op->reg = reg;
    op->dtype = calc_op_dtype(dtype);
    return op;
  }
  const op_t *make_op_imm(op_t *op, uval_t val, int8 dtype = -1) const
  {
    op->type = o_imm;
    op->value = val;
    op->dtype = calc_op_dtype(dtype);
    return op;
  }
  const op_t *make_op_displ(
        op_t *op,
        int base_reg,
        uval_t displ,
        int8 dtype = -1) const
  {
    op->type = o_displ;
    op->phrase = base_reg;
    op->addr = displ;
    op->dtype = calc_op_dtype(dtype);
    return op;
  }

  const op_t *make_op_phrase(
        op_t *op,
        int base_reg,
        int index_reg,
        int8 dtype = -1) const
  {
    op->type = o_phrase;
    op->phrase = base_reg;
    op->value = index_reg;
    op->dtype = calc_op_dtype(dtype);
    return op;
  }
 
protected:
  op_dtype_t calc_op_dtype(sint8 dtype) const
  {
    return dtype != -1        ? op_dtype_t(dtype)
         : eah().ea_size == 4 ? dt_dword
         :                      dt_qword;
  }
};
 
 
struct plugmod_t : public modctx_t
{
  size_t owner = 0;     // internal info used by the kernel

  virtual bool idaapi run(size_t arg) = 0;

  bool hook_event_listener(
        hook_type_t hook_type,
        event_listener_t *cb,
        int hkcb_flags=0)
  {
    return ::hook_event_listener(hook_type, cb, this, hkcb_flags);
  }

  virtual ~plugmod_t() {}
};
 
inline ssize_t processor_t::init(const char *idp_modname)
{
  return notify(ev_init, idp_modname);
}
inline ssize_t processor_t::term()
{
  return notify(ev_term);
}
inline ssize_t processor_t::newprc(int pnum, bool keep_cfg)
{
  return notify(ev_newprc, pnum, keep_cfg);
}
inline ssize_t processor_t::newasm(int asmnum)
{
  return notify(ev_newasm, asmnum);
}
inline ssize_t processor_t::asm_installed(int asmnum)
{
  return notify(ev_asm_installed, asmnum);
}
inline ssize_t processor_t::get_reg_accesses(reg_accesses_t *accvec, const insn_t &insn, int flags)
{
  return notify(ev_get_reg_accesses, accvec, &insn, flags);
}
inline ssize_t processor_t::is_control_flow_guard(int *p_reg, const insn_t *insn)
{
  return processor_t::notify(ev_is_control_flow_guard, p_reg, insn);
}
inline ssize_t processor_t::newfile(const char *fname)
{
  return notify(ev_newfile, fname);
}
inline ssize_t processor_t::oldfile(const char *fname)
{
  return notify(ev_oldfile, fname);
}
inline ssize_t processor_t::newbinary(const char *filename, qoff64_t fileoff, ea_t basepara, ea_t binoff, uint64 nbytes)
{
  return notify(ev_newbinary, filename, fileoff, basepara, binoff, nbytes);
}
inline ssize_t processor_t::endbinary(bool ok)
{
  return notify(ev_endbinary, ok);
}
inline ssize_t processor_t::creating_segm(segment_t *seg)
{
  return notify(ev_creating_segm, seg);
}
inline ssize_t processor_t::assemble(uchar *_bin, ea_t ea, ea_t cs, ea_t ip, bool _use32, const char *line)
{
  return notify(ev_assemble, _bin, ea, cs, ip, _use32, line, _bin);
}
inline ssize_t processor_t::ana_insn(insn_t *out)
{
  return notify(ev_ana_insn, out);
}
inline ssize_t processor_t::emu_insn(const insn_t &insn)
{
  return notify(ev_emu_insn, &insn);
}
inline ssize_t processor_t::out_header(outctx_t &ctx)
{
  return notify(ev_out_header, &ctx);
}
inline ssize_t processor_t::out_footer(outctx_t &ctx)
{
  return notify(ev_out_footer, &ctx);
}
inline ssize_t processor_t::out_segstart(outctx_t &ctx, segment_t *seg)
{
  return notify(ev_out_segstart, &ctx, seg);
}
inline ssize_t processor_t::out_segend(outctx_t &ctx, segment_t *seg)
{
  return notify(ev_out_segend, &ctx, seg);
}
inline ssize_t processor_t::out_assumes(outctx_t &ctx)
{
  return notify(ev_out_assumes, &ctx);
}
inline ssize_t processor_t::out_insn(outctx_t &ctx)
{
  return notify(ev_out_insn, &ctx);
}
inline ssize_t processor_t::out_mnem(outctx_t &ctx)
{
  return notify(ev_out_mnem, &ctx);
}
inline ssize_t processor_t::out_operand(outctx_t &ctx, const op_t &op)
{
  return notify(ev_out_operand, &ctx, &op);
}
inline ssize_t processor_t::out_data(outctx_t &ctx, bool analyze_only)
{
  return notify(ev_out_data, &ctx, analyze_only);
}
inline ssize_t processor_t::out_label(outctx_t &ctx, const char *colored_name)
{
  return notify(ev_out_label, &ctx, colored_name);
}
inline ssize_t processor_t::out_special_item(outctx_t &ctx, uchar segtype)
{
  return notify(ev_out_special_item, &ctx, segtype);
}
inline ssize_t processor_t::gen_stkvar_def(outctx_t &ctx, const struct udm_t *stkvar, sval_t v, tid_t tid)
{
  return notify(ev_gen_stkvar_def, &ctx, stkvar, v, tid);
}
inline ssize_t processor_t::gen_regvar_def(outctx_t &ctx, regvar_t *v)
{
  return notify(ev_gen_regvar_def, &ctx, v);
}
inline ssize_t processor_t::gen_src_file_lnnum(outctx_t &ctx, const char *file, size_t lnnum)
{
  return notify(ev_gen_src_file_lnnum, &ctx, file, lnnum);
}
inline ssize_t processor_t::rename(ea_t ea, const char *new_name, int flags)
{
  return notify(ev_rename, ea, new_name, flags);
}
inline ssize_t processor_t::may_show_sreg(ea_t current_ea)
{
  return notify(ev_may_show_sreg, current_ea);
}
inline ssize_t processor_t::coagulate(ea_t start_ea)
{
  return notify(ev_coagulate, start_ea);
}
inline void processor_t::auto_queue_empty(/*atype_t*/ int type)
{
  notify(ev_auto_queue_empty, type);
}
inline ssize_t processor_t::func_bounds(int *possible_return_code, func_t *pfn, ea_t max_func_end_ea)
{
  return notify(ev_func_bounds, possible_return_code, pfn, max_func_end_ea);
}
inline ssize_t processor_t::may_be_func(const insn_t &insn, int state)
{
  return notify(ev_may_be_func, &insn, state);
}
inline ssize_t processor_t::is_sane_insn(const insn_t &insn, int no_crefs)
{
  return notify(ev_is_sane_insn, &insn, no_crefs);
}
inline ssize_t processor_t::cmp_operands(const op_t &op1, const op_t &op2)
{
  return notify(ev_cmp_operands, &op1, &op2);
}
inline ssize_t processor_t::is_jump_func(func_t *pfn, ea_t *jump_target, ea_t *func_pointer)
{
  return notify(ev_is_jump_func, pfn, jump_target, func_pointer);
}
inline ssize_t processor_t::is_basic_block_end(const insn_t &insn, bool call_insn_stops_block)
{
  return notify(ev_is_basic_block_end, &insn, call_insn_stops_block);
}
inline ssize_t processor_t::getreg(uval_t *rv, int regnum)
{
  return notify(ev_getreg, rv, regnum);
}
inline ssize_t processor_t::undefine(ea_t ea)
{
  return notify(ev_undefine, ea);
}
inline ssize_t processor_t::moving_segm(segment_t *seg, ea_t to, int flags)
{
  return notify(ev_moving_segm, seg, to, flags);
}
inline ssize_t processor_t::is_sp_based(const insn_t &insn, const op_t &x)
{
  int mode;
  int code = notify(ev_is_sp_based, &mode, &insn, &x);
  return code == 0 ? OP_SP_BASED : mode;
}
inline ssize_t processor_t::is_far_jump(int icode)
{
  return notify(ev_is_far_jump, icode);
}
inline ssize_t processor_t::is_call_insn(const insn_t &insn)
{
  return notify(ev_is_call_insn, &insn);
}
inline ssize_t processor_t::is_ret_insn(const insn_t &insn, uchar iri_flags)
{
  return notify(ev_is_ret_insn, &insn, iri_flags);
}
inline ssize_t processor_t::is_align_insn(ea_t ea)
{
  return notify(ev_is_align_insn, ea);
}
inline ssize_t processor_t::is_addr_insn(int *type, const insn_t &insn)
{
  return notify(ev_is_addr_insn, type, &insn);
}
inline ssize_t processor_t::can_have_type(const op_t &op)
{
  ssize_t code = notify(ev_can_have_type, &op);
  return code != 0                             ? code
       : op.type == o_void || op.type == o_reg ? -1
       :                                         1;
}
inline ssize_t processor_t::get_stkvar_scale_factor()
{
  return notify(ev_get_stkvar_scale_factor);
}
inline ssize_t processor_t::demangle_name(int32 *res, qstring *out, const char *name, uint32 disable_mask, /*demreq_type_t*/ int demreq)
{
  return notify(ev_demangle_name, res, out, name, disable_mask, demreq);
}
inline ssize_t processor_t::create_flat_group(ea_t image_base, int bitness, sel_t dataseg_sel)
{
  return notify(ev_create_flat_group, image_base, bitness, dataseg_sel);
}
inline ssize_t processor_t::is_alloca_probe(ea_t ea)
{
  return notify(ev_is_alloca_probe, ea);
}
inline ssize_t processor_t::get_reg_name(qstring *buf, int reg, size_t width, int reghi)
{
  return notify(ev_get_reg_name, buf, reg, width, reghi);
}
inline ssize_t processor_t::gen_asm_or_lst(bool starting, FILE *fp, bool is_asm, int flags, /*html_line_cb_t ** */ void *outline)
{
  return notify(ev_gen_asm_or_lst, starting, fp, is_asm, flags, outline);
}
inline ssize_t processor_t::gen_map_file(int *nlines, FILE *fp)
{
  return notify(ev_gen_map_file, nlines, fp);
}
inline ssize_t processor_t::get_autocmt(qstring *buf, const insn_t &insn)
{
  return notify(ev_get_autocmt, buf, &insn);
}
inline ssize_t processor_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)
{
  return notify(ev_loader_elf_machine, li, machine_type, p_procname, p_pd, ldr, reader);
}
inline ssize_t processor_t::is_indirect_jump(const insn_t &insn)
{
  return notify(ev_is_indirect_jump, &insn);
}
inline ssize_t processor_t::verify_noreturn(func_t *pfn)
{
  return notify(ev_verify_noreturn, pfn);
}
inline ssize_t processor_t::verify_sp(func_t *pfn)
{
  return notify(ev_verify_sp, pfn);
}
inline ssize_t processor_t::create_func_frame(func_t *pfn)
{
  return notify(ev_create_func_frame, pfn);
}
inline ssize_t processor_t::get_frame_retsize(int *retsize, const func_t *pfn)
{
  return notify(ev_get_frame_retsize, retsize, pfn);
}
inline ssize_t processor_t::analyze_prolog(ea_t fct_ea)
{
  return notify(ev_analyze_prolog, fct_ea);
}
inline ssize_t processor_t::calc_spdelta(sval_t *spdelta, const insn_t &insn)
{
  return notify(ev_calc_spdelta, spdelta, &insn);
}
inline ssize_t processor_t::calcrel(bytevec_t *out_relbits, size_t *out_consumed, ea_t ea)
{
  return notify(ev_calcrel, out_relbits, out_consumed, ea);
}
inline ssize_t processor_t::find_reg_value(uval_t *out, const insn_t &insn, int reg)
{
  return notify(ev_find_reg_value, out, &insn, reg);
}
inline ssize_t processor_t::find_op_value(uval_t *out, const insn_t &insn, int opn)
{
  return notify(ev_find_op_value, out, &insn, opn);
}
inline ssize_t processor_t::treat_hindering_item(ea_t hindering_item_ea, flags64_t new_item_flags, ea_t new_item_ea, asize_t new_item_length)
{
  return notify(ev_treat_hindering_item, hindering_item_ea, new_item_flags, new_item_ea, new_item_length);
}
inline ssize_t processor_t::extract_address(ea_t *out_ea, ea_t screen_ea, const char *string, size_t x)
{
  return notify(ev_extract_address, out_ea, screen_ea, string, x);
}
inline ssize_t processor_t::str2reg(const char *regname)
{
  return notify(ev_str2reg, regname);
}
inline ssize_t processor_t::is_switch(switch_info_t *si, const insn_t &insn)
{
  return notify(ev_is_switch, si, &insn);
}
inline ssize_t processor_t::create_switch_xrefs(ea_t jumpea, const switch_info_t &si)
{
  return notify(ev_create_switch_xrefs, jumpea, &si);
}
inline ssize_t processor_t::calc_switch_cases(/*casevec_t * */void *casevec, eavec_t *targets, ea_t insn_ea, const switch_info_t &si)
{
  return notify(ev_calc_switch_cases, casevec, targets, insn_ea, &si);
}
inline ssize_t processor_t::get_bg_color(bgcolor_t *color, ea_t ea)
{
  return notify(ev_get_bg_color, color, ea);
}
inline ssize_t processor_t::validate_flirt_func(ea_t start_ea, const char *funcname)
{
  return notify(ev_validate_flirt_func, start_ea, funcname);
}
inline ssize_t processor_t::get_operand_string(qstring *buf, const insn_t &insn, int opnum)
{
  return notify(ev_get_operand_string, buf, &insn, opnum);
}
inline ssize_t processor_t::add_cref(ea_t from, ea_t to, cref_t type)
{
  return notify(ev_add_cref, from, to, type);
}
inline ssize_t processor_t::add_dref(ea_t from, ea_t to, dref_t type)
{
  return notify(ev_add_dref, from, to, type);
}
inline ssize_t processor_t::del_cref(ea_t from, ea_t to, bool expand)
{
  return notify(ev_del_cref, from, to, expand);
}
inline ssize_t processor_t::del_dref(ea_t from, ea_t to)
{
  return notify(ev_del_dref, from, to);
}
inline ssize_t processor_t::coagulate_dref(ea_t from, ea_t to, bool may_define, ea_t *code_ea)
{
  return notify(ev_coagulate_dref, from, to, may_define, code_ea);
}
inline const char *processor_t::set_idp_options(const char *keyword, int vtype, const void *value, bool idb_loaded)
{
  const char *errmsg = IDPOPT_BADKEY;
  int code = notify(ev_set_idp_options, keyword, vtype, value, &errmsg, idb_loaded);
  return code == 1 ? IDPOPT_OK : code == 0 ? IDPOPT_BADKEY : errmsg;
}
inline ssize_t processor_t::set_proc_options(const char *options, int confidence)
{
  return notify(ev_set_proc_options, options, confidence);
}
inline ssize_t processor_t::adjust_libfunc_ea(const idasgn_t &sig, const libfunc_t &libfun, ea_t *ea)
{
  return notify(ev_adjust_libfunc_ea, &sig, &libfun, ea);
}
inline fpvalue_error_t processor_t::realcvt(void *m, fpvalue_t *e, uint16 swt)
{
  return (fpvalue_error_t)notify(ev_realcvt, m, e, swt);
}
inline ssize_t processor_t::adjust_refinfo(refinfo_t *ri, ea_t ea, int n, const fixup_data_t &fd)
{
  return notify(ev_adjust_refinfo, ri, ea, n, &fd);
}
inline ssize_t processor_t::is_cond_insn(const insn_t &insn)
{
  return notify(ev_is_cond_insn, &insn);
}
inline ssize_t processor_t::set_code16_mode(ea_t ea, bool code16)
{
  return notify(ev_set_code16_mode, ea, code16);
}
inline bool processor_t::get_code16_mode(ea_t ea)
{
  return notify(ev_get_code16_mode, ea) == 1;
}
inline ssize_t processor_t::next_exec_insn(ea_t *target, ea_t ea, int tid, regval_getter_t *_getreg, const regval_t &regvalues)
{
  return notify(ev_next_exec_insn, target, ea, tid, _getreg, &regvalues);
}
inline ssize_t processor_t::calc_step_over(ea_t *target, ea_t ip)
{
  return notify(ev_calc_step_over, target, ip);
}
inline ssize_t processor_t::get_macro_insn_head(ea_t *head, ea_t ip)
{
  return notify(ev_get_macro_insn_head, head, ip);
}
inline ssize_t processor_t::get_dbr_opnum(int *opnum, const insn_t &insn)
{
  return notify(ev_get_dbr_opnum, opnum, &insn);
}
inline ssize_t processor_t::insn_reads_tbit(const insn_t &insn, regval_getter_t *_getreg, const regval_t &regvalues)
{
  return notify(ev_insn_reads_tbit, &insn, _getreg, &regvalues);
}
inline ssize_t processor_t::get_idd_opinfo(idd_opinfo_t *opinf, ea_t ea, int n, int thread_id, regval_getter_t *_getreg, const regval_t &regvalues)
{
  return notify(ev_get_idd_opinfo, opinf, ea, n, thread_id, _getreg, &regvalues);
}
inline ssize_t processor_t::update_call_stack(call_stack_t *stack, int thread_id, regval_getter_t *_getreg, const regval_t &regvalues)
{
  return notify(ev_update_call_stack, stack, thread_id, _getreg, &regvalues);
}
inline ssize_t processor_t::calc_next_eas(eavec_t *res, const insn_t &insn, bool over)
{
  return notify(ev_calc_next_eas, res, &insn, over);
}
inline ssize_t processor_t::clean_tbit(ea_t ea, regval_getter_t *_getreg, const regval_t &regvalues)
{
  return notify(ev_clean_tbit, ea, _getreg, &regvalues);
}
inline ssize_t processor_t::setup_til()
{
  return notify(ev_setup_til);
}
inline ssize_t processor_t::max_ptr_size()
{
  ssize_t code = notify(ev_max_ptr_size);
  if ( code == 0 )
    code = 4;
  return code;
}
inline ssize_t processor_t::calc_cdecl_purged_bytes(ea_t ea)
{
  return notify(ev_calc_cdecl_purged_bytes, ea);
}
// Use global calc_retloc() instead of this:
inline ssize_t processor_t::_calc_retloc(argloc_t *retloc, const tinfo_t &rettype, callcnv_t cc)
{
  return notify(ev_calc_retloc, retloc, &rettype, cc);
}
// Use global calc_varglocs() instead of this:
inline ssize_t processor_t::_calc_varglocs(func_type_data_t *ftd, regobjs_t *regs, relobj_t *stkargs, int nfixed)
{
  return notify(ev_calc_varglocs, ftd, regs, stkargs, nfixed);
}
// Use global calc_arglocs() instead of this:
inline ssize_t processor_t::_calc_arglocs(func_type_data_t *fti)
{
  return notify(ev_calc_arglocs, fti);
}
inline ssize_t processor_t::use_stkarg_type(ea_t ea, const funcarg_t &arg)
{
  return notify(ev_use_stkarg_type, ea, &arg);
}
inline ssize_t processor_t::use_regarg_type(int *idx, ea_t ea, /*const funcargvec_t * */void *rargs)
{
  return notify(ev_use_regarg_type, idx, ea, rargs);
}
inline ssize_t processor_t::use_arg_types(ea_t ea, func_type_data_t *fti, /*funcargvec_t * */void *rargs)
{
  return notify(ev_use_arg_types, ea, fti, rargs);
}
inline ssize_t processor_t::calc_purged_bytes(int *p_purged_bytes, const func_type_data_t &fti)
{
  return notify(ev_calc_purged_bytes, p_purged_bytes, &fti);
}
inline ssize_t processor_t::get_cc_regs(callregs_t *regs, callcnv_t cc)
{
  return notify(ev_get_cc_regs, regs, cc);
}
inline ssize_t processor_t::get_simd_types(/*simd_info_vec_t * */void *out, const simd_info_t *simd_attrs, const argloc_t *argloc, bool create_tifs)
{
  return notify(ev_get_simd_types, out, simd_attrs, argloc, create_tifs);
}
inline ssize_t processor_t::arg_addrs_ready(ea_t caller, int n, const tinfo_t &tif, ea_t *addrs)
{
  return notify(ev_arg_addrs_ready, caller, n, &tif, addrs);
}
inline ssize_t processor_t::adjust_argloc(argloc_t *argloc, const tinfo_t *type, int size)
{
  return notify(ev_adjust_argloc, argloc, type, size);
}
inline ssize_t processor_t::lower_func_type(intvec_t *argnums, func_type_data_t *fti)
{
  return notify(ev_lower_func_type, argnums, fti);
}
inline ssize_t processor_t::get_abi_info(qstrvec_t *abi_names, qstrvec_t *abi_opts, comp_t comp)
{
  return notify(ev_get_abi_info, abi_names, abi_opts, comp);
}
inline ssize_t processor_t::arch_changed()
{
  return notify(ev_arch_changed);
}
inline ssize_t processor_t::create_merge_handlers(merge_data_t *md)
{
  return notify(ev_create_merge_handlers, md);
}
inline ssize_t processor_t::privrange_changed(const range_t &old_privrange, adiff_t delta, qstring *errbuf)
{
  return notify(ev_privrange_changed, &old_privrange, delta, errbuf);
}
inline ssize_t processor_t::cvt64_supval(nodeidx_t node, uchar tag, nodeidx_t idx, const uchar *data, size_t datlen, qstring *errbuf)
{
  return notify(ev_cvt64_supval, node, tag, idx, data, datlen, errbuf);
}
inline ssize_t processor_t::cvt64_hashval(nodeidx_t node, uchar tag, const char *name, const uchar *data, size_t datlen, qstring *errbuf)
{
  return notify(ev_cvt64_hashval, node, tag, name, data, datlen, errbuf);
}
inline reg_finder_t *processor_t::get_regfinder()
{
  return (reg_finder_t *)notify(ev_get_regfinder);
}
 
idaman int ida_export str2reg(const char *p);     
 

 
idaman int ida_export is_align_insn(ea_t ea);
 

 
idaman ssize_t ida_export get_reg_name(qstring *buf, int reg, size_t width, int reghi = -1);
 

 
inline const char *processor_t::get_reg_info(const char *regname, bitrange_t *bitrange)
{
  const char *r2;
  int code = notify(ev_get_reg_info, &r2, bitrange, regname);
  if ( code == 0 ) // not implemented?
  {
    if ( ::str2reg(regname) != -1 )
    {
      if ( bitrange != nullptr )
        bitrange->reset();
      return regname;
    }
    return nullptr;
  }
  return code == 1 ? r2 : nullptr;
}

struct reg_info_t
{
  int reg;              
  int size;             
  DECLARE_COMPARISONS(reg_info_t)
  {
    if ( reg != r.reg )
      return reg > r.reg ? 1 : -1;
    if ( size != r.size )
      return size > r.size ? 1 : -1;
    return 0;
  }
};
DECLARE_TYPE_AS_MOVABLE(reg_info_t);
typedef qvector<reg_info_t> reginfovec_t; 
 

 
idaman bool ida_export parse_reg_name(reg_info_t *ri, const char *regname);
 

enum access_type_t ENUM_SIZE(uchar)
{
  NO_ACCESS = 0,
  WRITE_ACCESS = 1,
  READ_ACCESS = 2,
  RW_ACCESS = WRITE_ACCESS | READ_ACCESS,
};

struct reg_access_t
{
  int regnum = 0;        
  bitrange_t range;      
  access_type_t access_type = NO_ACCESS;
  uchar opnum = 0;       
 
  bool have_common_bits(const reg_access_t &r) const
  {
    return regnum == r.regnum && range.has_common(r.range);
  }
 
  bool operator==(const reg_access_t &r) const
  {
    return regnum == r.regnum
        && range == r.range
        && access_type == r.access_type
        && opnum == r.opnum;
  }
 
  bool operator!=(const reg_access_t &r) const
  {
    return !(*this == r);
  }
};
DECLARE_TYPE_AS_MOVABLE(reg_access_t);
typedef qvector<reg_access_t> reg_access_vec_t;
 
struct reg_accesses_t : public reg_access_vec_t {};
 
 
inline bool insn_t::is_canon_insn(const processor_t &_ph) const // see ::insn_t in ua.hpp
{
  return _ph.is_canon_insn(itype);
}
 
inline const char *insn_t::get_canon_mnem(const processor_t &_ph) const // see ::insn_t in ua.hpp
{
  return _ph.get_canon_mnem(itype);
}
 
inline uint32 insn_t::get_canon_feature(const processor_t &_ph) const // ::insn_t in ua.hpp
{
  return _ph.get_canon_feature(itype);
}
 

inline size_t processor_t::sizeof_ldbl() const
{
  return inf_get_cc_size_ldbl() ? inf_get_cc_size_ldbl() : tbyte_size;
}

enum setproc_level_t
{
  SETPROC_IDB = 0,    
  SETPROC_LOADER = 1, 
  SETPROC_LOADER_NON_FATAL = 2, 
  SETPROC_USER = 3,   
};

 
idaman bool ida_export set_processor_type(
        const char *procname,
        setproc_level_t level);
 

 
idaman char *ida_export get_idp_name(char *buf, size_t bufsize);
 

 
idaman bool ida_export set_target_assembler(int asmnum);
 

inline bool processor_t::delay_slot_insn(ea_t *ea, bool *bexec, bool *fexec)
{
  bool ok = (flag & PR_DELAYED) != 0;
  if ( ok )
  {
    bool be = true;
    bool fe = true;
    ok = notify(ev_delay_slot_insn, ea, &be, &fe) == 1;
    if ( ok )
    {
      if ( bexec != nullptr )
        *bexec = be;
      if ( fexec != nullptr )
        *fexec = fe;
    }
  }
  return ok;
}
 
enum local_type_change_t
{
  LTC_NONE,         
  LTC_ADDED,        
  LTC_DELETED,      
  LTC_EDITED,       
  LTC_ALIASED,      
  LTC_COMPILER,     
  LTC_TIL_LOADED,   
  LTC_TIL_UNLOADED, 
  LTC_TIL_COMPACTED,
};

namespace idb_event
{
  //<hookgen IDB>

  enum event_code_t
  {
    closebase,              
 
    savebase,               
 
    upgraded,               
 
    auto_empty,             
 
    auto_empty_finally,     
 
    determined_main,        
 
    extlang_changed,        
 
    idasgn_loaded,          
 
    kernel_config_loaded,   
 
    loader_finished,        
 
    flow_chart_created,     
 
    compiler_changed,       
 
    changing_ti,            
 
    ti_changed,             
 
    changing_op_ti,         
    op_ti_changed,          
 
    changing_op_type,       
    op_type_changed,        
 
    segm_added,             
 
    deleting_segm,          
    segm_deleted,           
 
    changing_segm_start,    
    segm_start_changed,     
 
    changing_segm_end,      
    segm_end_changed,       
 
    changing_segm_name,     
    segm_name_changed,      
 
    changing_segm_class,    
    segm_class_changed,     
 
    segm_attrs_updated,     
 
    segm_moved,             
 
    allsegs_moved,          
 
    func_added,             
 
    func_updated,           
 
    set_func_start,         
 
    set_func_end,           
 
    deleting_func,          
                            //
    frame_deleted,          
 
    thunk_func_created,     
 
    func_tail_appended,     
 
    deleting_func_tail,     
 
    func_tail_deleted,      
 
    tail_owner_changed,     
 
    func_noret_changed,     
 
    stkpnts_changed,        
 
    updating_tryblks,       
    tryblks_updated,        
 
    deleting_tryblks,       
                            //
    sgr_changed,            
 
    make_code,              
 
    make_data,              
 
    destroyed_items,        
 
    renamed,                
 
    byte_patched,           
 
    changing_cmt,           
    cmt_changed,            
 
    changing_range_cmt,     
    range_cmt_changed,      
 
    extra_cmt_changed,      
 
    item_color_changed,     
 
    callee_addr_changed,    
 
    bookmark_changed,       
 
    sgr_deleted,            
 
    adding_segm,            
 
    func_deleted,           
 
    dirtree_mkdir,          
 
    dirtree_rmdir,          
 
    dirtree_link,           
 
    dirtree_move,           
 
    dirtree_rank,           
 
    dirtree_rminode,        
 
    dirtree_segm_moved,     
 
    local_types_changed,    
 
    lt_udm_created,         
 
    lt_udm_deleted,         
 
    lt_udm_renamed,         
 
    lt_udm_changed,         
 
    lt_udt_expanded,        
 
    frame_created,          
 
    frame_udm_created,      
 
    frame_udm_deleted,      
 
    frame_udm_renamed,      
 
    frame_udm_changed,      
 
    frame_expanded,         
 
    idasgn_matched_ea,      
 
    lt_edm_created,         
 
    lt_edm_deleted,         
 
    lt_edm_renamed,         
 
    lt_edm_changed,         
 
    local_type_renamed,     
 
  };
}
 

 
inline void gen_idb_event(idb_event::event_code_t code, ...)
{
  if ( errorexit )
    return;
  va_list va;
  va_start(va, code);
  invoke_callbacks(HT_IDB, code, va);
  va_end(va);
}
 
inline int processor_t::get_proc_index(void)
{
  qstring curproc = inf_get_procname();
  for ( size_t i = 0; psnames[i] != nullptr; ++i )
  {
    const char *p = psnames[i];
    if ( p[0] == '-' ) // obsolete processor names start with a '-'
      ++p;
    if ( curproc == p )
      return i;
  }
  // should not reach here
  INTERR(10336);
}


 
idaman void *ida_export set_module_data(int *data_id, void *data_ptr);
 

 
idaman void *ida_export clr_module_data(int data_id);
 
 

 
idaman void *ida_export get_module_data(int data_id);
 
// Convenience macros to handle the module data.
// They assume the existence of a global variable "int data_id"
#define SET_MODULE_DATA(type) (type *)set_module_data(&data_id, new type)
#define GET_MODULE_DATA(type) ((type *)get_module_data(data_id))
 
 
#endif // _IDP_HPP