ua.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _UA_HPP
#define _UA_HPP
 
#include <kernwin.hpp>  // for btoa()
#include <lines.hpp>    // for colors
#include <xref.hpp>     // add_cref()
#include <bytes.hpp>    // get_byte(), ...

 
struct procmod_t;
struct processor_t;
struct asm_t;

 
//--------------------------------------------------------------------------
//      T Y P E   O F   O P E R A N D
//--------------------------------------------------------------------------
typedef uchar optype_t; 
const optype_t
  o_void     =  0, 
  o_reg      =  1, 
  o_mem      =  2, 
  o_phrase   =  3, 
  o_displ    =  4, 
  o_imm      =  5, 
  o_far      =  6, 
  o_near     =  7, 
  o_idpspec0 =  8, 
  o_idpspec1 =  9, 
  o_idpspec2 = 10, 
  o_idpspec3 = 11, 
  o_idpspec4 = 12, 
  o_idpspec5 = 13; 

 
//--------------------------------------------------------------------------
//      O P E R A N D   O F   I N S T R U C T I O N
//--------------------------------------------------------------------------

class op_t
{
public:

  uchar n = 0;

  optype_t type = o_void;

  char offb = 0;

  char offo = 0;
 
  uchar flags = 0;            
#define OF_NO_BASE_DISP 0x80  
#define OF_OUTER_DISP   0x40  
#define PACK_FORM_DEF   0x20  
#define OF_NUMBER       0x10  
#define OF_SHOW         0x08  

  void set_shown()     { flags |=  OF_SHOW; }
  void clr_shown()     { flags &= ~OF_SHOW; }
  bool shown() const   { return (flags & OF_SHOW) != 0; }

  op_dtype_t dtype = 0;
// from here..
#define dt_byte         0     
#define dt_word         1     
#define dt_dword        2     
#define dt_float        3     
#define dt_double       4     
#define dt_tbyte        5     
#define dt_packreal     6     
// ...to here the order should not be changed, see mc68000
#define dt_qword        7     
#define dt_byte16       8     
#define dt_code         9     
#define dt_void         10    
#define dt_fword        11    
#define dt_bitfild      12    
#define dt_string       13    
#define dt_unicode      14    
#define dt_ldbl         15    
#define dt_byte32       16    
#define dt_byte64       17    
#define dt_half         18    
 
  // REG
  union
  {
    uint16 reg;               
    uint16 phrase;            
  };

  bool is_reg(int r) const { return type == o_reg && reg == r; }
 
  //  Next fields (value, addr) bytes are used by mc68k for some float types
 
  // VALUE
  union
  {
    uval_t value;             

    struct
    {
      uint16 low;
      uint16 high;
    } value_shorts;
  };

  bool is_imm(uval_t v) const { return type == o_imm && value == v; }
 
  // VIRTUAL ADDRESS (offset within the segment)
  union
  {
    ea_t addr;                

    struct
    {
      uint16 low;
      uint16 high;
    } addr_shorts;
  };
 
  // IDP SPECIFIC INFORMATION
  union
  {
    ea_t specval;             
    struct
    {
      uint16 low;             
      uint16 high;            
    } specval_shorts;
  };

  char specflag1 = 0;
  char specflag2 = 0;
  char specflag3 = 0;
  char specflag4 = 0;
 
  op_t()
  {
    reg = 0;
    value = 0;
    addr = 0;
    specval = 0;
    specflag1 = 0;
    specflag2 = 0;
    specflag3 = 0;
    specflag4 = 0;
  }
};
 
 
//--------------------------------------------------------------------------
//      I N S T R U C T I O N
//--------------------------------------------------------------------------

 
class insn_t;
#define DECLARE_INSN_HELPERS(decl) \
decl uint8  ida_export insn_get_next_byte(insn_t *insn); \
decl uint16 ida_export insn_get_next_word(insn_t *insn); \
decl uint32 ida_export insn_get_next_dword(insn_t *insn); \
decl uint64 ida_export insn_get_next_qword(insn_t *insn); \
decl bool ida_export insn_create_op_data(const insn_t &insn, ea_t ea, int opoff, op_dtype_t dtype); \
decl void ida_export insn_add_cref(const insn_t &insn, ea_t to, int opoff, cref_t type); \
decl void ida_export insn_add_dref(const insn_t &insn, ea_t to, int opoff, dref_t type); \
decl ea_t ida_export insn_add_off_drefs(const insn_t &insn, const op_t &x, dref_t type, int outf); \
decl bool ida_export insn_create_stkvar(const insn_t &insn, const op_t &x, adiff_t v, int flags);
 
DECLARE_INSN_HELPERS(idaman)
 
 
class insn_t
{
public:
  insn_t() : auxpref(0) {}

  ea_t cs = BADADDR;

  ea_t ip = BADADDR;

  ea_t ea = BADADDR;

  uint16 itype = 0;
 
  inline bool is_canon_insn(const processor_t &ph) const;         
  inline uint32 get_canon_feature(const processor_t &ph) const;   
  inline const char *get_canon_mnem(const processor_t &ph) const; 

  uint16 size = 0;
 
  union
  {
    uint32 auxpref;             
    uint16 auxpref_u16[2];
    uint8  auxpref_u8[4];
  };
  /*u*/ char segpref = 0;       
  /*u*/ char insnpref = 0;      
 
  /*u*/ int16 flags = 0;        
 
  op_t ops[UA_MAXOP];           

  #define Op1 ops[0]       
  #define Op2 ops[1]       
  #define Op3 ops[2]       
  #define Op4 ops[3]       
  #define Op5 ops[4]       
  #define Op6 ops[5]       
  #define Op7 ops[6]       
  #define Op8 ops[7]       

#define INSN_MACRO  0x01        
#define INSN_MODMAC 0x02        
#define INSN_64BIT  0x04        

  bool is_macro(void) const { return (flags & INSN_MACRO) != 0; }

#ifdef __EA64__
  bool is_64bit(void) const { return (flags & INSN_64BIT) != 0; }
#else
  bool is_64bit(void) const { return false; }
#endif

  uint8 get_next_byte()
  {
    return insn_get_next_byte(this);
  }
  uint16 get_next_word()
  {
    return insn_get_next_word(this);
  }
  uint32 get_next_dword()
  {
    return insn_get_next_dword(this);
  }
  uint64 get_next_qword()
  {
    return insn_get_next_qword(this);
  }


 
  bool create_op_data(ea_t ea_, int opoff, op_dtype_t dtype) const
  {
    return insn_create_op_data(*this, ea_, opoff, dtype);
  }

  bool create_op_data(ea_t ea_, const op_t &op) const
  {
    return insn_create_op_data(*this, ea_, op.offb, op.dtype);
  }
 

 
  bool create_stkvar(const op_t &x, adiff_t v, int stkvar_flags) const
  {
    return insn_create_stkvar(*this, x, v, stkvar_flags);
  }

 
  void add_cref(ea_t to, int opoff, cref_t type) const
  {
    insn_add_cref(*this, to, opoff, type);
  }
 

 
  void add_dref(ea_t to, int opoff, dref_t type) const
  {
    insn_add_dref(*this, to, opoff, type);
  }
 

 
  ea_t add_off_drefs(const op_t &x, dref_t type, int outf) const
  {
    return insn_add_off_drefs(*this, x, type, outf);
  }

 
  DECLARE_INSN_HELPERS(friend)
};
#ifdef __EA64__
CASSERT(sizeof(insn_t) == 360);
#else
CASSERT(sizeof(insn_t) == 216);
#endif
 
//--------------------------------------------------------------------------
//      V A L U E   O F   O P E R A N D
//--------------------------------------------------------------------------
#ifndef SWIG
union value_union_t // 16 bytes max
{
  uint8  v_char;
  uint16 v_short;
  uint32 v_long;
  uint64 v_int64;
  uval_t v_uval;
  struct dq_t { uint32 low; uint32 high; } _dq;
  struct dt_t { uint32 low; uint32 high; uint16 upper; } dt;
  struct d128_t { uint64 low; uint64 high; } d128;
  uint8 byte16[16];
};
 
#endif // SWIG

 
idaman size_t ida_export get_immvals(
        uval_t *out,
        ea_t ea,
        int n,
        flags64_t F,
        insn_t *cache=nullptr);
 

 
inline size_t get_printable_immvals(
        uval_t *out,
        ea_t ea,
        int n,
        flags64_t F,
        insn_t *cache=nullptr)
{
  F &= ~0x100; // no FF_IVL...
  F |= 0xFF;   // ...but a value of 0xFF
  return get_immvals(out, ea, n, F, cache);
}
 

 
idaman int ida_export get_lookback(void);
 
 
//--------------------------------------------------------------------------
//      I D P   H E L P E R   F U N C T I O N S  -  C O M M O N
//--------------------------------------------------------------------------


 
idaman ea_t ida_export calc_dataseg(const insn_t &insn, int n=-1, int rgnum=-1);

 
inline ea_t map_data_ea(const insn_t &insn, ea_t addr, int opnum=-1)
{
  return to_ea(calc_dataseg(insn, opnum), addr);
}
 
inline ea_t map_data_ea(const insn_t &insn, const op_t &op)
{
  return map_data_ea(insn, op.addr, op.n);
}

 
idaman ea_t ida_export map_code_ea(const insn_t &insn, ea_t addr, int opnum);
 
inline ea_t map_code_ea(const insn_t &insn, const op_t &op)
{
  return map_code_ea(insn, op.addr, op.n);
}
 
inline ea_t map_ea(const insn_t &insn, const op_t &op, bool iscode)
{
  return iscode ? map_code_ea(insn, op) : map_data_ea(insn, op);
}
 
inline ea_t map_ea(const insn_t &insn, ea_t addr, int opnum, bool iscode)
{
  return iscode ? map_code_ea(insn, addr, opnum) : map_data_ea(insn, addr, opnum);
}

 
//--------------------------------------------------------------------------
//      I D P   H E L P E R   F U N C T I O N S  -  O U T P U T
//--------------------------------------------------------------------------
struct outctx_base_t
{
  ea_helper_t &_eah;
  // information for creating one line
  ea_t insn_ea;
  qstring outbuf;              
  ssize_t regname_idx = -1;    
  int suspop;                  
  flags_t F32;                 
  uval_t *outvalues = nullptr; 
  int outvalue_getn_flags = 0; 
  void *user_data = nullptr;   
  void *kern_data = nullptr;   
 
  // information for generating many lines
  qstrvec_t *lnar = nullptr;   
  int lnar_maxsize = 0;        
  int default_lnnum = -1;      
 
  qstring line_prefix;         
  ssize_t prefix_len = 0;      
  int ctxflags = 0;            
#define CTXF_MAIN         0x00001 
#define CTXF_MULTI        0x00002 
#define CTXF_CODE         0x00004 
#define CTXF_STACK        0x00008 
#define CTXF_GEN_XREFS    0x00010 
#define CTXF_XREF_STATE   0x00060 
#define   XREFSTATE_NONE   0x00   
#define   XREFSTATE_GO     0x20   
#define   XREFSTATE_DONE   0x40   
#define CTXF_GEN_CMT      0x00080 
#define CTXF_CMT_STATE    0x00300 
#define   COMMSTATE_NONE   0x000  
#define   COMMSTATE_GO     0x100  
#define   COMMSTATE_DONE   0x200  
#define CTXF_VOIDS        0x00400 
#define CTXF_NORMAL_LABEL 0x00800 
#define CTXF_DEMANGLED_LABEL 0x01000 
#define CTXF_LABEL_OK     0x02000 
#define CTXF_DEMANGLED_OK 0x04000 
#define CTXF_OVSTORE_PRNT 0x08000 
#define CTXF_OUTCTX_T     0x10000 
#define CTXF_DBLIND_OPND  0x20000 
#define CTXF_BINOP_STATE  0xC0000 
#define   BINOPSTATE_NONE  0x00000 
#define   BINOPSTATE_GO    0x40000 
#define   BINOPSTATE_DONE  0x80000 
#define CTXF_HIDDEN_ADDR  0x100000 
#define CTXF_BIT_PREFIX   0x200000 
#define CTXF_UNHIDE       0x400000 
 
  // internal data used by the kernel
  int ind0 = 0;
  ea_t cmt_ea = BADADDR;        
  qstring cmtbuf;               
  const char *cmtptr = nullptr; 
  color_t cmtcolor = 0xFF;      
 
  inline bool only_main_line() const { return (ctxflags & CTXF_MAIN) != 0; }
  inline bool multiline() const { return (ctxflags & CTXF_MULTI) != 0; }
  inline bool force_code() const { return (ctxflags & CTXF_CODE) != 0; }
  inline bool stack_view() const { return (ctxflags & CTXF_STACK) != 0; }
  inline bool display_voids() const { return (ctxflags & CTXF_VOIDS) != 0; }
  inline bool display_hidden() const { return (ctxflags & CTXF_UNHIDE) != 0; }
  inline void set_gen_xrefs(bool on=true) { setflag(ctxflags, CTXF_GEN_XREFS, on); }
  inline int get_xrefgen_state() const { return ctxflags & CTXF_XREF_STATE; }
  inline void set_gen_cmt(bool on=true) { setflag(ctxflags, CTXF_GEN_CMT, on); }
  inline int get_cmtgen_state() const { return ctxflags & CTXF_CMT_STATE; }
  inline int get_binop_state() const { return ctxflags & CTXF_BINOP_STATE; }
  inline void clr_gen_label(void) { ctxflags &= ~(CTXF_NORMAL_LABEL|CTXF_DEMANGLED_LABEL); }
  inline void set_gen_label(void) { ctxflags |= CTXF_NORMAL_LABEL; }
  inline void set_gen_demangled_label(void) { ctxflags |= CTXF_DEMANGLED_LABEL; ctxflags &= ~CTXF_NORMAL_LABEL; }
  inline void set_comment_addr(ea_t ea) { cmt_ea = ea; }
  inline void set_dlbind_opnd(void) { ctxflags |= CTXF_DBLIND_OPND; }
  inline bool print_label_now() const
  {
    return (ctxflags & (CTXF_LABEL_OK|CTXF_MAIN)) == 0                 // label not ready
        && (ctxflags & (CTXF_NORMAL_LABEL|CTXF_DEMANGLED_LABEL)) != 0; // requested it
  }
  int forbid_annotations()
  { // temporarily forbid printing of xrefs, label, cmt
    int bits = CTXF_GEN_XREFS|CTXF_NORMAL_LABEL|CTXF_DEMANGLED_LABEL|CTXF_GEN_CMT;
    int saved_flags = ctxflags & bits;
    ctxflags &= ~bits;
    return saved_flags;
  }
  void restore_ctxflags(int saved_flags)
  {
    ctxflags |= saved_flags;
  }
 
  outctx_base_t(ea_t ea, flags64_t flags, int _suspop=0);
  outctx_base_t &operator =(const outctx_base_t &) = delete;
  virtual ~outctx_base_t(void);


  AS_PRINTF(2, 3) size_t out_printf(const char *format, ...)
  {
    va_list va;
    va_start(va, format);
    size_t len = out_vprintf(format, va);
    va_end(va);
    return len;
  }
 
  GCC_DIAG_OFF(format-nonliteral);
  size_t nowarn_out_printf(const char *format, ...)
  {
    va_list va;
    va_start(va, format);
    size_t len = out_vprintf(format, va);
    va_end(va);
    return len;
  }
  GCC_DIAG_ON(format-nonliteral);
 
  virtual AS_PRINTF(2, 0) size_t idaapi out_vprintf(const char *format, va_list va);

  virtual flags64_t idaapi out_value(const op_t &x, int outf=0);

#define OOF_SIGNMASK    0x0003      
#define   OOFS_IFSIGN   0x0000      
#define   OOFS_NOSIGN   0x0001      
#define   OOFS_NEEDSIGN 0x0002      
#define OOF_SIGNED      0x0004      
#define OOF_NUMBER      0x0008      
#define OOF_WIDTHMASK   0x0070      
#define   OOFW_IMM      0x0000      
#define   OOFW_8        0x0010      
#define   OOFW_16       0x0020      
#define   OOFW_24       0x0030      
#define   OOFW_32       0x0040      
#define   OOFW_64       0x0050      
#define OOF_ADDR        0x0080      
#define OOF_OUTER       0x0100      
#define OOF_ZSTROFF     0x0200      
#define OOF_NOBNOT      0x0400      
#define OOF_SPACES      0x0800      
#define OOF_ANYSERIAL   0x1000      
#define OOF_LZEROES     0x2000      
#define OOF_NO_LZEROES  0x4000      

  virtual void idaapi out_symbol(char c);

  virtual void idaapi out_chars(char c, int n);

  void out_spaces(ssize_t len) { add_spaces(&outbuf, len); }
  virtual void idaapi add_spaces(qstring *buf, ssize_t len);

  virtual void idaapi out_line(const char *str, color_t color=0);

  inline void out_keyword(const char *str)
  {
    out_line(str, COLOR_KEYWORD);
  }

  inline void out_register(const char *str)
  {
    out_line(str, COLOR_REG);
  }

  inline void out_lvar(const char *name, int width=-1)
  {
    out_line(name, COLOR_LOCNAME);
    if ( width != -1 && name != nullptr )
    {
      size_t len = ::qstrlen(name);
      if ( len < width )
        out_chars(' ', int(width - len));
    }
  }

  virtual void idaapi out_tagon(color_t tag);

  virtual void idaapi out_tagoff(color_t tag);

  virtual void idaapi out_addr_tag(ea_t ea);

  virtual void idaapi out_colored_register_line(const char *str);

  virtual void idaapi out_char(char c) { outbuf.append(c); }

  virtual void idaapi out_btoa(uval_t Word, char radix=0);

  virtual void idaapi out_long(sval_t v, char radix);

  virtual bool idaapi out_name_expr(
        const op_t &x,
        ea_t ea,
        adiff_t off=BADADDR);
 
  // Generate the closing comment if if it required by the assembler
 
  inline void close_comment(void) { out_line(closing_comment()); }


  virtual bool idaapi flush_outbuf(int indent=-1);

  virtual bool idaapi flush_buf(const char *buf, int indent=-1);

  virtual int idaapi term_outctx(const char *prefix=nullptr);

  virtual AS_PRINTF(3, 0) bool idaapi gen_vprintf(
        int indent,
        const char *format,
        va_list va);

 
  AS_PRINTF(3, 4) inline bool gen_printf(int indent, const char *format, ...)
  {
    va_list va;
    va_start(va, format);
    bool code = gen_vprintf(indent, format, va);
    va_end(va);
    return code;
  }
#define DEFAULT_INDENT 0xFFFF

 
  virtual bool idaapi gen_empty_line(void);
 

 
  virtual bool idaapi gen_border_line(bool solid=false);

  virtual AS_PRINTF(3, 0) bool idaapi gen_colored_cmt_line_v(
          color_t color,
          const char *format,
          va_list va);

 
  AS_PRINTF(2, 0) inline bool gen_cmt_line_v(const char *format, va_list va)
  {
    return gen_colored_cmt_line_v(COLOR_AUTOCMT, format, va);
  }

 
  AS_PRINTF(2, 3) inline bool gen_cmt_line(const char *format, ...)
  {
    va_list va;
    va_start(va, format);
    bool code = gen_cmt_line_v(format, va);
    va_end(va);
    return code;
  }

 
  AS_PRINTF(2, 3) inline bool gen_collapsed_line(const char *format, ...)
  {
    va_list va;
    va_start(va,format);
    bool answer = gen_colored_cmt_line_v(COLOR_COLLAPSED, format, va);
    va_end(va);
    return answer;
  }

 
  virtual bool idaapi gen_block_cmt(const char *cmt, color_t color);
 
  //-------------------------------------------------------------------------
  virtual void idaapi setup_outctx(const char *prefix, int makeline_flags);
#define MAKELINE_NONE           0x00
#define MAKELINE_BINPREF        0x01    
#define MAKELINE_VOID           0x02    
#define MAKELINE_STACK          0x04    
 
  virtual ssize_t idaapi retrieve_cmt(void) { return -1; }
  virtual ssize_t idaapi retrieve_name(qstring *, color_t *) { return -1; }
  virtual bool idaapi gen_xref_lines(void) { return false; }
 
  virtual void idaapi init_lines_array(qstrvec_t *answers, int maxsize);
 
  virtual ssize_t idaapi get_stkvar(const op_t &x, uval_t v, sval_t *vv, int *is_sp_based, tinfo_t *_frame);
 
  void gen_empty_line_without_annotations(void)
  {
    int saved_flags = forbid_annotations();
    gen_empty_line();
    restore_ctxflags(saved_flags);
  }
 
  inline flags64_t getF() const;
 
protected:
  virtual bool idaapi flush_and_reinit(void);
  virtual void idaapi append_user_prefix(const char *, int) {}
  virtual void idaapi add_aux_prefix(const char *, int) {}
  virtual void idaapi out_label_addr_tag(void) {}
  virtual void idaapi out_aux_cmts(void) {}
  friend struct outctx_base_internal_t;
};
 
//--------------------------------------------------------------------------
// This class is used to print instructions and data items
struct outctx_t : public outctx_base_t
{
  // kernel only data:
  ea_t bin_ea;                 // Current binary format EA
  char bin_state;              // =0 not generated,1-in process,2-finished
  int gl_bpsize = 0;           // binary line prefix size
  int bin_width = 0;
 
  // instruction to display:
  insn_t insn;                 // valid only when ph.out_insn() is called
 
  // colorized and demangled label of the current address
  qstring curlabel;
 
  // opinfo_t to use for out_value()
  const printop_t *wif;
 
  // processor module and its description
  procmod_t *procmod;
  processor_t &ph;
  asm_t &ash;
 
  // out_value() saves the printed values here
  uval_t saved_immvals[UA_MAXOP] = { 0 };
 
  ea_t prefix_ea = BADADDR;
  ea_t next_line_ea = BADADDR;       // EA of next line (for prefix)
  flags64_t F = 0;
 
  outctx_t(
        procmod_t *p,
        processor_t &ph,
        asm_t &ash,
        ea_t ea,
        flags64_t flags=0,
        int _suspop=0,
        const printop_t *_wif=nullptr);
  ~outctx_t(void)
  {
  }
  virtual void idaapi setup_outctx(const char *prefix, int flags) override;
  virtual int idaapi term_outctx(const char *prefix=nullptr) override;
  virtual ssize_t idaapi retrieve_cmt(void) override;
  virtual ssize_t idaapi retrieve_name(qstring *, color_t *) override;
  virtual bool idaapi gen_xref_lines(void) override;
  virtual void idaapi out_btoa(uval_t Word, char radix=0) override;
 
  void set_bin_state(int value)
  {
    bin_state = value;
    ctxflags &= ~CTXF_BINOP_STATE;
    ctxflags |= value == 0 ? BINOPSTATE_NONE
              : value == 1 ? BINOPSTATE_GO
              :              BINOPSTATE_DONE;
  }

  virtual void idaapi out_mnem(int width=8, const char *postfix=nullptr) newapi;

  virtual void idaapi out_custom_mnem(
        const char *mnem,
        int width=8,
        const char *postfix=nullptr) newapi;

  virtual void idaapi out_mnemonic(void) newapi;

  virtual bool idaapi out_one_operand(int n) newapi;

  virtual size_t idaapi get_immvals(uval_t *out, int i) newapi;

  virtual void idaapi out_immchar_cmts(void) newapi;

  DEPRECATED virtual void idaapi gen_func_header(func_t *pfn) newapi;
  DEPRECATED virtual void idaapi gen_func_footer(const func_t *pfn) newapi;
 
  // display data items and undefined bytes.
  virtual void idaapi out_data(bool analyze_only) newapi;
 
  // generate declaration for item in a special segment
  // return: 0-ok, 1-overflow
  virtual bool idaapi out_specea(uchar segtype) newapi;
 
  // convenience functions for processor modules
  // print lines from ash.header
  virtual void idaapi gen_header_extra() newapi;
 
  // flags for gen_header()
#define GH_PRINT_PROC           (1 << 0)  
#define GH_PRINT_ASM            (1 << 1)  
#define GH_PRINT_BYTESEX        (1 << 2)  
#define GH_PRINT_HEADER         (1 << 3)  
#define GH_BYTESEX_HAS_HIGHBYTE (1 << 4)  
#define GH_PRINT_PROC_AND_ASM (GH_PRINT_PROC | GH_PRINT_ASM)
#define GH_PRINT_PROC_ASM_AND_BYTESEX (GH_PRINT_PROC_AND_ASM | GH_PRINT_BYTESEX)
#define GH_PRINT_ALL (GH_PRINT_PROC_ASM_AND_BYTESEX | GH_PRINT_HEADER)
#define GH_PRINT_ALL_BUT_BYTESEX (GH_PRINT_PROC_AND_ASM | GH_PRINT_HEADER)
  virtual void idaapi gen_header(
        int flags = GH_PRINT_PROC_AND_ASM,
        const char *proc_name = nullptr,
        const char *proc_flavour = nullptr) newapi;

  virtual void idaapi out_fcref_names() newapi;

  virtual void idaapi gen_function_header(ea_t func_ea) newapi;

  virtual void idaapi gen_function_footer(ea_t func_ea) newapi;
  friend struct outctx_internal_t;

protected:
  virtual bool idaapi flush_and_reinit(void) override;
  virtual void idaapi add_aux_prefix(const char *contents, int indent) override;
  virtual void idaapi append_user_prefix(const char *contents, int indent) override;
 
private:
  virtual void idaapi out_label_addr_tag() override;
  virtual void idaapi out_aux_cmts() override;
  virtual ssize_t idaapi get_stkvar(const op_t &x, uval_t v, sval_t *vv, int *is_sp_based, tinfo_t *_frame) override;
 
 
public:
  virtual void idaapi out_unmapped_addr(ea_t addr, char radix=16) newapi;
};
 
//-------------------------------------------------------------------------
inline flags64_t outctx_base_t::getF() const
{
  return (ctxflags & CTXF_OUTCTX_T) != 0 ? ((outctx_t *) this)->F : F32;
}
 
//--------------------------------------------------------------------------
 
idaman outctx_base_t *ida_export create_outctx(ea_t ea, flags64_t F=0, int suspop=0);
 

 
idaman bool ida_export print_insn_mnem(qstring *out, ea_t ea);
 

#define FCBF_CONT     0x00000001 
#define FCBF_ERR_REPL 0x00000002 
 
#define FCBF_FF_LIT   0x00000004 
 
#define FCBF_DELIM    0x00000008 
 

 
idaman bool ida_export format_charlit(
        qstring *out,
        const uchar **ptr,
        size_t size,
        uint32 flags=0,
        int encidx=0);
 

 
idaman bool ida_export print_fpval(char *buf, size_t bufsize, const void *v, int size);
 
 
//--------------------------------------------------------------------------
//      I D P   H E L P E R   F U N C T I O N S  -  E M U L A T O R
//--------------------------------------------------------------------------
idaman flags64_t ida_export get_dtype_flag(op_dtype_t dtype);
idaman size_t ida_export get_dtype_size(op_dtype_t dtype);
idaman op_dtype_t ida_export get_dtype_by_size(asize_t size);

inline bool is_floating_dtype(op_dtype_t dtype)
{
  return dtype == dt_float
      || dtype == dt_double
      || dtype == dt_tbyte
      || dtype == dt_ldbl
      || dtype == dt_half;
}
 
 
//--------------------------------------------------------------------------
template <class Derived>
struct reglist_base_t
{
  uint64 regs = 0;
 
  bool empty() const { return regs == 0; }
  void clear() { regs = 0; }
  int count() const { return bitcount(regs); }
  void add(int regnum) { regs |= _encode(regnum); }
  template<typename... Args>
  void add(int regnum, Args... args) { add(regnum); add(args...); }
  void add(const reglist_base_t &r) { regs |= r.regs; }
  void add_range(int first, int count)
  {
    while ( count-- > 0 )
      add(first++);
  }
  void del(int regnum) { regs &= ~_encode(regnum); }
  void del(const reglist_base_t &r) { regs &= ~r.regs; }
  void intersect(const reglist_base_t &r) { regs &= r.regs; }
  bool has(int regnum) const { return (regs & _encode(regnum)) != 0; }
  bool has_any(const reglist_base_t &r) const { return (regs & r.regs) != 0; }
  bool contains(const reglist_base_t &r) const { return (r.regs & ~regs) == 0; }
  DECLARE_COMPARISONS(reglist_base_t)
  {
    return ::compare(regs, r.regs);
  }
  // FUNC can return a non-zero code to immediately exit the loop
  int for_each(std::function<int(int)> func) const
  {
    uint64 bitmask = regs;
    int bitnum = bitcountr_zero(bitmask);
    for ( bitmask >>= bitnum; bitmask != 0; bitmask >>= 1 )
    {
      if ( (bitmask & 1) != 0 )
      {
        int code = func(_decode(bitnum));
        if ( code != 0 )
          return code;
      }
      ++bitnum;
    }
    return 0;
  }
  int first_reg() const { return _decode(bitcountr_zero(regs)); }
  // print the register list taking into account consecutive registers
  void print(
        outctx_t *out,
        std::function<void(outctx_t *,int)> print_reg,
        const char *delim) const
  {
    int last_reg = -1;
    size_t count = 0;
    for_each([out, print_reg, delim, &last_reg, &count](int reg)
      {
        if ( last_reg >= 0 && reg == last_reg + 1 )
        { // count consecutive registers
          ++count;
          ++last_reg;
        }
        else
        {
          if ( count > 1 )
          { // output the register range
            out->out_line(count == 2 ? delim : "-", COLOR_SYMBOL);
            print_reg(out, last_reg);
          }
          if ( count != 0 )
            out->out_line(delim, COLOR_SYMBOL);
          print_reg(out, reg);
          // start new register range
          last_reg = reg;
          count = 1;
        }
        return 0;
      } );
    if ( count > 1 )
    {
      out->out_line(count == 2 ? delim : "-", COLOR_SYMBOL);
      print_reg(out, last_reg);
    }
  }
 
protected:
  uint64 _encode(int regnum) const
  {
    return static_cast<const Derived *>(this)->encode(regnum);
  }
  int _decode(int bitnum) const
  {
    return static_cast<const Derived *>(this)->decode(bitnum);
  }
};
 
 
//--------------------------------------------------------------------------
//      K E R N E L   I N T E R F A C E   T O   I D P   F U N C T I O N S
//--------------------------------------------------------------------------
idaman int ida_export create_insn(ea_t ea, insn_t *out=nullptr);
 

 
idaman int ida_export decode_insn(insn_t *out, ea_t ea);

 
inline bool can_decode(ea_t ea) { insn_t insn; return decode_insn(&insn, ea) > 0; }
 

 
idaman bool ida_export print_operand(
        qstring *out,
        ea_t ea,
        int n,
        int getn_flags=0,
        struct printop_t *newtype=nullptr);
 
 
//--------------------------------------------------------------------------
//      Helper functions for the processor emulator/analyzer
//--------------------------------------------------------------------------

 
idaman ea_t ida_export decode_prev_insn(insn_t *out, ea_t ea);
 

 
idaman ea_t ida_export decode_preceding_insn(insn_t *out, ea_t ea, bool *p_farref=nullptr);
 

struct macro_constructor_t
{
  size_t reserved = 0;
 
  virtual ~macro_constructor_t() {}

  inline bool construct_macro(insn_t *insn, bool enable);

  virtual bool idaapi build_macro(insn_t *insn, bool may_go_forward) = 0;
};
 
// Do not directly call this function, use macro_constructor_t
idaman bool ida_export construct_macro(
        macro_constructor_t *_this,
        insn_t *insn,
        bool enable);
 
inline bool macro_constructor_t::construct_macro(insn_t *insn, bool enable)
{
  return ::construct_macro(this, insn, enable);
}
 

 
idaman int ida_export get_spoiled_reg(const insn_t &insn, const uint32 *regs, size_t n);
 
#endif // _UA_HPP