segment.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _SEGMENT_HPP
#define _SEGMENT_HPP
 
#include <ida.hpp>
#include <range.hpp>            // segments are range of addresses
                                // with characteristics


 

#define SREG_NUM 16
 
 
//-------------------------------------------------------------------------
//      D E F I N I T O N   O F   S E G M E N T   S T R U C T U R E
//-------------------------------------------------------------------------

class segment_t : public range_t
{
public:
/*  8 */  uval_t name;          
/* 12 */  uval_t sclass;        
/* 16 */  uval_t orgbase;       
 
/* 20 */  uchar align;          
#define saAbs           0       
#define saRelByte       1       
#define saRelWord       2       
#define saRelPara       3       
#define saRelPage       4       
#define saRelDble       5       
#define saRel4K         6       
#define saGroup         7       
#define saRel32Bytes    8       
#define saRel64Bytes    9       
#define saRelQword     10       
#define saRel128Bytes  11       
#define saRel512Bytes  12       
#define saRel1024Bytes 13       
#define saRel2048Bytes 14       
#define saRel_MAX_ALIGN_CODE saRel2048Bytes
 
/* 21 */  uchar comb;           
#define scPriv     0            
#define scGroup    1            
#define scPub      2            
#define scPub2     4            
#define scStack    5            
#define scCommon   6            
#define scPub3     7            
#define sc_MAX_COMB_CODE    scPub3
 
/* 22 */  uchar perm;           
#define SEGPERM_EXEC  1         
#define SEGPERM_WRITE 2         
#define SEGPERM_READ  4         
#define SEGPERM_MAXVAL (SEGPERM_EXEC + SEGPERM_WRITE + SEGPERM_READ) 
 
/* 23 */  uchar bitness;        
#define SEG_MAX_BITNESS_CODE 2 

          bool is_16bit(void) const { return bitness == 0; }
          bool is_32bit(void) const { return bitness == 1; }
          bool is_64bit(void) const { return bitness == 2; }
          int  abits(void) const { return 1<<(bitness+4); }
          int  abytes(void) const { return abits() / 8; }

 
/* 24 */  ushort flags;         

#define SFL_COMORG      0x01

  bool comorg(void) const { return (flags & SFL_COMORG) != 0; }
  void set_comorg(void) { flags |= SFL_COMORG; }
  void clr_comorg(void) { flags &= ~SFL_COMORG; }

#define SFL_OBOK        0x02

  bool ob_ok(void) const { return (flags & SFL_OBOK) != 0; }
  void set_ob_ok(void) { flags |= SFL_OBOK; }
  void clr_ob_ok(void) { flags &= ~SFL_OBOK; }

#define SFL_HIDDEN      0x04

  bool is_visible_segm(void) const { return (flags & SFL_HIDDEN) == 0; }
  void set_visible_segm(bool visible) { setflag(flags, SFL_HIDDEN, !visible); }

#define SFL_DEBUG       0x08

  bool is_debugger_segm(void) const { return (flags & SFL_DEBUG) != 0; }
  // use ::change_segment_status() to change the segment state during debugging
  void set_debugger_segm(bool debseg) { setflag(flags, SFL_DEBUG, debseg); }

#define SFL_LOADER      0x10

  bool is_loader_segm(void) const { return (flags & SFL_LOADER) != 0; }
  void set_loader_segm(bool ldrseg) { setflag(flags, SFL_LOADER, ldrseg); }

#define SFL_HIDETYPE    0x20

  bool is_hidden_segtype(void) const { return (flags & SFL_HIDETYPE) != 0; }
  void set_hidden_segtype(bool hide) { setflag(flags, SFL_HIDETYPE, hide); }

#define SFL_HEADER    0x40

  bool is_header_segm(void) const { return (flags & SFL_HEADER) != 0; }
  void set_header_segm(bool on) { setflag(flags, SFL_HEADER, on); }

  bool is_ephemeral_segm(void) const
    { return (flags & (SFL_DEBUG|SFL_LOADER)) == SFL_DEBUG; }
 
/* 28 */  sel_t sel;            
 
/* 32 */  sel_t defsr[SREG_NUM];
 
/* 96 */  uchar type;           

#define SEG_NORM        0       
#define SEG_XTRN        1       
#define SEG_CODE        2       
#define SEG_DATA        3       
#define SEG_IMP         4       
#define SEG_GRP         6       
#define SEG_NULL        7       
#define SEG_UNDF        8       
#define SEG_BSS         9       
#define SEG_ABSSYM     10       
#define SEG_COMM       11       
#define SEG_IMEM       12       
#define SEG_MAX_SEGTYPE_CODE SEG_IMEM 
 
/* 100 */ bgcolor_t color;      

  inline bool update(void);

  segment_t(void)
    : name(0),
      sclass(0),
      orgbase(0),
      align(0),
      comb(0),
      perm(0),
      bitness(0),
      flags(0),
      sel(0),
      type(SEG_NORM),
      color(DEFCOLOR)
  {
    memset(defsr, 0, sizeof(defsr));
  }
 
#ifndef SWIG
  DECLARE_COMPARISONS(segment_t);
#endif
}; // total 104/192 bytes
 
#ifdef __EA64__
CASSERT(sizeof(segment_t) == 192);
#else
CASSERT(sizeof(segment_t) == 104);
#endif

inline bool is_visible_segm(segment_t *s) { return s != nullptr && s->is_visible_segm(); }
inline bool is_finally_visible_segm(segment_t *s)
{
  return (inf_get_cmtflg() & SCF_SHHID_SEGM) != 0 || is_visible_segm(s);
}

idaman void ida_export set_visible_segm(segment_t *s, bool visible);
 

 
idaman bool ida_export is_spec_segm(uchar seg_type);
 

 
idaman bool ida_export is_spec_ea(ea_t ea);
 

 
idaman void ida_export lock_segm(const segment_t *segm, bool lock);

class lock_segment
{
  const segment_t *segm;
public:
  lock_segment(const segment_t *_segm) : segm(_segm)
  {
    lock_segm(segm, true);
  }
  ~lock_segment(void)
  {
    lock_segm(segm, false);
  }
};

idaman bool ida_export is_segm_locked(const segment_t *segm);

 
//-------------------------------------------------------------------------
//      S E G M E N T   S E L E C T O R S
//
//-------------------------------------------------------------------------

 
idaman bool ida_export getn_selector(sel_t *sel, ea_t *base, int n);
 

 
idaman size_t ida_export get_selector_qty(void);
 

 
idaman sel_t ida_export setup_selector(ea_t segbase);
 

 
idaman sel_t ida_export allocate_selector(ea_t segbase);
 

 
idaman sel_t ida_export find_free_selector(void);
 

 
idaman int ida_export set_selector(sel_t selector, ea_t paragraph);
 

 
idaman void ida_export del_selector(sel_t selector);
 

 
idaman ea_t ida_export sel2para(sel_t selector);
 

 
inline ea_t idaapi sel2ea(sel_t selector)
{
  if ( selector == BADSEL )
    return BADADDR;
  return to_ea(sel2para(selector), 0);
}
 

 
idaman sel_t ida_export find_selector(ea_t base);
 

 
idaman int ida_export enumerate_selectors(int (idaapi *func)(sel_t sel,ea_t para));
 

 
idaman ea_t ida_export enumerate_segments_with_selector(
        sel_t selector,
        ea_t (idaapi *func)(segment_t *s, void *ud),
        void *ud=nullptr);
 

 
idaman segment_t *ida_export get_segm_by_sel(sel_t selector);

 
//-------------------------------------------------------------------------
//      S E G M E N T   M A N I P U L A T I O N   F U N C T I O N S
//-------------------------------------------------------------------------

 
idaman bool ida_export add_segm_ex(
        segment_t *NONNULL s,
        const char *name,
        const char *sclass,
        int flags);
#define ADDSEG_NOSREG   0x0001  
#define ADDSEG_OR_DIE   0x0002  
#define ADDSEG_NOTRUNC  0x0004  
#define ADDSEG_QUIET    0x0008  
#define ADDSEG_FILLGAP  0x0010  
#define ADDSEG_SPARSE   0x0020  
#define ADDSEG_NOAA     0x0040  
#define ADDSEG_IDBENC   0x0080  
 

 
idaman bool ida_export add_segm(
        ea_t para,
        ea_t start,
        ea_t end,
        const char *name,
        const char *sclass,
        int flags=0);
 

 
idaman bool ida_export del_segm(ea_t ea, int flags);

#define SEGMOD_KILL    0x0001 
#define SEGMOD_KEEP    0x0002 
#define SEGMOD_SILENT  0x0004 
#define SEGMOD_KEEP0   0x0008 
#define SEGMOD_KEEPSEL 0x0010 
#define SEGMOD_NOMOVE  0x0020 
#define SEGMOD_SPARSE  0x0040 
 

 
idaman int ida_export get_segm_qty(void);
 

 
idaman segment_t *ida_export getseg(ea_t ea);
 

 
idaman segment_t *ida_export getnseg(int n);
 

idaman int ida_export get_segm_num(ea_t ea);
 

idaman segment_t *ida_export get_next_seg(ea_t ea);
idaman segment_t *ida_export get_prev_seg(ea_t ea);

idaman segment_t *ida_export get_first_seg(void);
idaman segment_t *ida_export get_last_seg(void);
 

 
idaman segment_t *ida_export get_segm_by_name(const char *name);
 

 
idaman bool ida_export set_segm_end(ea_t ea, ea_t newend, int flags);
 

 
idaman bool ida_export set_segm_start(ea_t ea, ea_t newstart, int flags);
 

 
idaman bool ida_export move_segm_start(ea_t ea, ea_t newstart, int mode);
 

enum move_segm_code_t
{
  MOVE_SEGM_OK          =  0,  
  MOVE_SEGM_PARAM       = -1,  
  MOVE_SEGM_ROOM        = -2,  
  MOVE_SEGM_IDP         = -3,  
  MOVE_SEGM_CHUNK       = -4,  
  MOVE_SEGM_LOADER      = -5,  
  MOVE_SEGM_ODD         = -6,  
  MOVE_SEGM_ORPHAN      = -7,  
  MOVE_SEGM_DEBUG       = -8,  
  MOVE_SEGM_SOURCEFILES = -9,  
  MOVE_SEGM_MAPPING     = -10, 
  MOVE_SEGM_INVAL       = -11, 
};

 

idaman const char *ida_export move_segm_strerror(move_segm_code_t code);
 

 
idaman move_segm_code_t ida_export move_segm(segment_t *s, ea_t to, int flags=0);

#define MSF_SILENT    0x0001    
#define MSF_NOFIX     0x0002    
#define MSF_LDKEEP    0x0004    
#define MSF_FIXONCE   0x0008    
#define MSF_PRIORITY  0x0020    
#define MSF_NETNODES  0x0080    

 
idaman move_segm_code_t ida_export rebase_program(adiff_t delta, int flags);
 

 
idaman int ida_export change_segment_status(segment_t *s, bool is_deb_segm);

#define CSS_OK       0          
#define CSS_NODBG   -1          
#define CSS_NORANGE -2          
#define CSS_NOMEM   -3          
#define CSS_BREAK   -4          
 

#define SNAP_ALL_SEG        0       
#define SNAP_LOAD_SEG       1       
#define SNAP_CUR_SEG        2       

 
idaman bool ida_export take_memory_snapshot(int type);

 
idaman bool ida_export is_miniidb(void);
 

 
idaman bool ida_export set_segm_base(segment_t *s, ea_t newbase);

 
//-------------------------------------------------------------------------
//      S E G M E N T   G R O U P S
//-------------------------------------------------------------------------
 

 
idaman int ida_export set_group_selector(sel_t grp, sel_t sel);
 
#define MAX_GROUPS      8   
 

 
idaman sel_t ida_export get_group_selector(sel_t grpsel);

 
//-------------------------------------------------------------------------
//      S E G M E N T   T R A N S L A T I O N S
//-------------------------------------------------------------------------

 
idaman bool ida_export add_segment_translation(ea_t segstart, ea_t mappedseg);
 
#define MAX_SEGM_TRANSLATIONS   64      
 

 
idaman bool ida_export set_segment_translations(ea_t segstart, const eavec_t &transmap);
 

 
idaman void ida_export del_segment_translations(ea_t segstart);
 

 
idaman ssize_t ida_export get_segment_translations(eavec_t *transmap, ea_t segstart);
 
//-------------------------------------------------------------------------
//      S E G M E N T   C O M M E N T S
//
//-------------------------------------------------------------------------

 
idaman ssize_t ida_export get_segment_cmt(qstring *buf, const segment_t *s, bool repeatable);
 

 
idaman void ida_export set_segment_cmt(const segment_t *s, const char *cmt, bool repeatable);
 

 
idaman void ida_export std_out_segm_footer(struct outctx_t &ctx, segment_t *seg);

 
//-------------------------------------------------------------------------
//      S E G M E N T   N A M E S
//-------------------------------------------------------------------------

 
idaman int ida_export set_segm_name(
        segment_t *s,
        const char *name,
        int flags=0);
 

 
idaman ssize_t ida_export get_segm_name(qstring *buf, const segment_t *s, int flags=0);
 

 
inline ssize_t idaapi get_visible_segm_name(qstring *buf, const segment_t *s)
{
  return get_segm_name(buf, s, 1);
}
 

 
ssize_t get_segm_expr(qstring *buf, ea_t from, sel_t sel);

 
//-------------------------------------------------------------------------
//      S E G M E N T   C L A S S E S   A N D   T Y P E S
//-------------------------------------------------------------------------

 
idaman ssize_t ida_export get_segm_class(qstring *buf, const segment_t *s);
 

 
idaman int ida_export set_segm_class(segment_t *s, const char *sclass, int flags=0);
 

 
idaman uchar ida_export segtype(ea_t ea);

 
//-------------------------------------------------------------------------
//      S E G M E N T   A L I G N M E N T   A N D   C O M B I N A T I O N
//-------------------------------------------------------------------------

 
idaman const char *ida_export get_segment_alignment(uchar align);
 

 
idaman const char *ida_export get_segment_combination(uchar comb);

 
//-------------------------------------------------------------------------
//      S E G M E N T   A D D R E S S I N G
//-------------------------------------------------------------------------

 
idaman ea_t ida_export get_segm_para(const segment_t *s);
 

 
idaman ea_t ida_export get_segm_base(const segment_t *s);
 

 
idaman bool ida_export set_segm_addressing(segment_t *s, size_t bitness);

 
//-----------------------------------------------------------------------

 
inline bool is_debugger_segm(ea_t ea)
{
  segment_t *s = getseg(ea);
  return s != nullptr && s->is_debugger_segm();
}

 
inline bool is_ephemeral_segm(ea_t ea)
{
  segment_t *s = getseg(ea);
  return s != nullptr && s->is_ephemeral_segm();
}
 
//-------------------------------------------------------------------------
idaman ea_t ida_export correct_address(ea_t ea, ea_t from, ea_t to, ea_t size, bool skip_check=false);
 
//-------------------------------------------------------------------------
idaman bool ida_export update_segm(segment_t *s);
 
inline bool segment_t::update(void)
{
  return update_segm(this);
}

idaman adiff_t ida_export segm_adjust_diff(const segment_t *s, adiff_t delta);

idaman ea_t ida_export segm_adjust_ea(const segment_t *s, ea_t ea);
 
#endif // _SEGMENT_HPP