segment.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _SEGMENT_HPP
#define _SEGMENT_HPP
 
#include <functional>
#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
//-------------------------------------------------------------------------

#define SFL_COMORG      0x01
#define SFL_OBOK        0x02
#define SFL_HIDDEN      0x04
#define SFL_DEBUG       0x08
#define SFL_LOADER      0x10
#define SFL_HIDETYPE    0x20
#define SFL_HEADER    0x40

#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 

#define SEGPERM_EXEC  1 
#define SEGPERM_WRITE 2 
#define SEGPERM_READ  4 
#define SEGPERM_MAXVAL (SEGPERM_EXEC + SEGPERM_WRITE + SEGPERM_READ) 

#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

#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
 
#define SEG_MAX_BITNESS_CODE 2 

class segment_info_t;
#define DECLARE_SEGMENT_HELPERS(decl)\
decl bool ida_export segment_info_t__visible_name(const segment_info_t *_this, qstring *); \
 
DECLARE_SEGMENT_HELPERS(idaman)
 

class segment_info_t : public range_t
{
public:
  segment_info_t() { memset(defsr_, -1, sizeof(defsr_)); }

  bool is_valid() const { return !empty(); }

  bool has(int gsi_flags) const { return (filled_ & gsi_flags) == gsi_flags; }

  const char *get_name() const { return qname_.c_str(); }
  bool visible_name(qstring *out) const { return segment_info_t__visible_name(this, out); }
  void set_name(const char *v) { qname_ = v; updated_ |= SI_NAME; }

  const char *get_sclass() const { return qsclass_.c_str(); }
  void set_sclass(const char *v) { qsclass_ = v; updated_ |= SI_SCLASS; }

  uval_t get_orgbase() const { return orgbase_; }
  void set_orgbase(uval_t v) { orgbase_ = v; updated_ |= SI_ORGBASE; }

  uchar get_align() const { return align_; }
  void set_align(uchar v) { align_ = v; updated_ |= SI_ALIGN; }

  uchar get_comb() const { return comb_; }
  void set_comb(uchar v) { comb_ = v; updated_ |= SI_COMB; }

  uchar get_perm() const { return perm_; }
  void set_perm(uchar v) { perm_ = v; updated_ |= SI_PERM; }

  uchar get_bitness() const { return bitness_; }
  void set_bitness(uchar v) { bitness_ = v; updated_ |= SI_BITNESS; }

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

  ushort get_flags() const { return flags_; }
  void set_flags(ushort v) { flags_ = v; updated_ |= SI_FLAGS; }

  bool comorg() const { return (flags_ & SFL_COMORG) != 0; }
  void set_comorg(bool v=true) { setflag(flags_, SFL_COMORG, v); updated_ |= SI_FLAGS; }

  bool ob_ok() const { return (flags_ & SFL_OBOK) != 0; }
  void set_ob_ok(bool v=true) { setflag(flags_, SFL_OBOK, v); updated_ |= SI_FLAGS; }

  bool is_visible_segm() const { return (flags_ & SFL_HIDDEN) == 0; }
  bool is_finally_visible_segm() const { return (inf_get_cmtflg() & SCF_SHHID_SEGM) != 0 || is_visible_segm(); }
  void set_visible_segm(bool visible=true) { setflag(flags_, SFL_HIDDEN, !visible); updated_ |= SI_FLAGS; }

  bool is_debugger_segm() const { return (flags_ & SFL_DEBUG) != 0; }
  void set_debugger_segm(bool debseg=true) { setflag(flags_, SFL_DEBUG, debseg); updated_ |= SI_FLAGS; }

  bool is_loader_segm() const { return (flags_ & SFL_LOADER) != 0; }
  void set_loader_segm(bool ldrseg=true) { setflag(flags_, SFL_LOADER, ldrseg); updated_ |= SI_FLAGS; }

  bool is_hidden_segtype() const { return (flags_ & SFL_HIDETYPE) != 0; }
  void set_hidden_segtype(bool hide=true) { setflag(flags_, SFL_HIDETYPE, hide); updated_ |= SI_FLAGS; }

  bool is_header_segm() const { return (flags_ & SFL_HEADER) != 0; }
  void set_header_segm(bool on=true) { setflag(flags_, SFL_HEADER, on); updated_ |= SI_FLAGS; }

  bool is_ephemeral_segm() const
    { return (flags_ & (SFL_DEBUG|SFL_LOADER)) == SFL_DEBUG; }

  sel_t get_sel() const { return sel_; }
  void set_sel(sel_t v) { sel_ = v; updated_ |= SI_SEL; }

  inline ea_t para() const;

  ea_t base() const { return to_ea(para(), 0); }

  sel_t get_defsr(int sr_idx) const { return (sr_idx >= 0 && sr_idx < SREG_NUM) ? defsr_[sr_idx] : BADSEL; }
  void set_defsr(int sr_idx, sel_t v) { if ( sr_idx >= 0 && sr_idx < SREG_NUM ) { defsr_[sr_idx] = v; updated_ |= si_defsr(sr_idx); } }

  uchar get_type() const { return type_; }
  void set_type(uchar v) { type_ = v; updated_ |= SI_TYPE; }

  bgcolor_t get_color() const { return color_; }
  void set_color(bgcolor_t v) { color_ = v; updated_ |= SI_COLOR; }

  const char *get_cmt_reg() const { return cmt_reg_.c_str(); }
  void set_cmt_reg(const char *v) { cmt_reg_ = v; updated_ |= SI_CMT_REG; }

  const char *get_cmt_rpt() const { return cmt_rpt_.c_str(); }
  void set_cmt_rpt(const char *v) { cmt_rpt_ = v; updated_ |= SI_CMT_RPT; }
 
private:
  static constexpr int SI_VERSION = 1;
 
  uint64 updated_ = 0;        
  int filled_ = 0;            
  qstring qname_;             
  qstring qsclass_;           
  qstring cmt_reg_;           
  qstring cmt_rpt_;           
  uval_t orgbase_ = 0;        
  uchar align_ = 0;           
  uchar comb_ = 0;            
  uchar perm_ = 0;            
  uchar bitness_ = 0;         
  ushort flags_ = 0;          
  sel_t sel_ = 0;             
  sel_t defsr_[SREG_NUM];     
  uchar type_ = SEG_NORM;     
  bgcolor_t color_ = DEFCOLOR;
  uchar version_ = SI_VERSION;   
 
  DECLARE_SEGMENT_HELPERS(friend)
  friend struct kdata_t;

  enum
  {
    SI_SEL        = 0x00000001,  
    SI_ORGBASE    = 0x00000002,  
    SI_FLAGS      = 0x00000004,  
    SI_TYPE       = 0x00000008,  
    SI_PERM       = 0x00000010,  
    SI_BITNESS    = 0x00000020,  
    SI_ALIGN      = 0x00000040,  
    SI_COMB       = 0x00000080,  
    SI_COLOR      = 0x00000100,  
    SI_NAME       = 0x00000200,  
    SI_SCLASS     = 0x00000400,  
    SI_CMT_REG    = 0x00000800,  
    SI_CMT_RPT    = 0x00001000,  
    SI_DEFSR_FIRST= 0x00002000,  
    SI_ALL_FIELDS = 0x00001FFF,  
    SI_ALL_DEFSR  = 0x1FFFE000,  
    SI_ALL        = 0x1FFFFFFF,  
  };
  static uint64 si_defsr(int rg) { return SI_DEFSR_FIRST << rg; }
};

 
//-------------------------------------------------------------------------
// INTERNAL

class segment_t : public range_t
{
public:
  uval_t name = 0;      
  uval_t sclass = 0;    
  uval_t orgbase = 0;   
 
  uchar align = 0;      
  uchar comb = 0;       
  uchar perm = 0;       
  uchar bitness = 0;    
  bool is_16bit() const { return bitness == 0; }
  bool is_32bit() const { return bitness == 1; }
  bool is_64bit() const { return bitness == 2; }
  int  abits() const { return 1<<(bitness+4); }
  int  abytes() const { return abits() / 8; }

 
  ushort flags = 0;     
  bool comorg() const { return (flags & SFL_COMORG) != 0; }
  void set_comorg() { flags |= SFL_COMORG; }
  void clr_comorg() { flags &= ~SFL_COMORG; }
  bool ob_ok() const { return (flags & SFL_OBOK) != 0; }
  void set_ob_ok() { flags |= SFL_OBOK; }
  void clr_ob_ok() { flags &= ~SFL_OBOK; }
  bool is_visible_segm() const { return (flags & SFL_HIDDEN) == 0; }
  void set_visible_segm(bool visible) { setflag(flags, SFL_HIDDEN, !visible); }
  bool is_debugger_segm() 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); }
  bool is_loader_segm() const { return (flags & SFL_LOADER) != 0; }
  void set_loader_segm(bool ldrseg) { setflag(flags, SFL_LOADER, ldrseg); }
  bool is_hidden_segtype() const { return (flags & SFL_HIDETYPE) != 0; }
  void set_hidden_segtype(bool hide) { setflag(flags, SFL_HIDETYPE, hide); }
  bool is_header_segm() const { return (flags & SFL_HEADER) != 0; }
  void set_header_segm(bool on) { setflag(flags, SFL_HEADER, on); }

  bool is_ephemeral_segm() const
    { return (flags & (SFL_DEBUG|SFL_LOADER)) == SFL_DEBUG; }
 
  sel_t sel = 0;        
 
  sel_t defsr[SREG_NUM];
 
  uchar type = SEG_NORM;
 
 bgcolor_t color = DEFCOLOR; 

  inline bool update();

  segment_t()
  {
    memset(defsr, -1, sizeof(defsr)); // BADSEL
  }
 
#ifndef SWIG
  DECLARE_COMPARISONS(segment_t);
#endif
}; // total 192 bytes
 
#ifdef __EA64__
CASSERT(sizeof(segment_t) == 192);
#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 DEPRECATED void ida_export set_visible_segm(segment_t *s, bool visible);

 
idaman void ida_export set_visible_segment(ea_t ea, bool visible);
 

 
idaman bool ida_export is_spec_segm(uchar seg_type);
 

 
idaman bool ida_export is_spec_ea(ea_t ea);
 

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

 
idaman void ida_export lock_segment_by_ea(ea_t ea, bool lock);

class DEPRECATED lock_segment
{
  ea_t ea = BADADDR;
public:
  lock_segment(const segment_t *segm)
  {
    if ( segm != nullptr )
    {
      ea = segm->start_ea;
      lock_segment_by_ea(ea, true);
    }
  }
  ~lock_segment()
  {
    if ( ea != BADADDR )
      lock_segment_by_ea(ea, false);
  }
};

class lock_segment_ea
{
  ea_t seg_ea;
public:
  lock_segment_ea(ea_t ea) : seg_ea(ea)
  {
    lock_segment_by_ea(seg_ea, true);
  }
  ~lock_segment_ea()
  {
    lock_segment_by_ea(seg_ea, false);
  }
};

idaman DEPRECATED bool ida_export is_segm_locked(const segment_t *segm);

 
idaman bool ida_export is_segment_locked(ea_t ea);

 
//-------------------------------------------------------------------------
//      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();
 

 
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();
 

 
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 DEPRECATED ea_t ida_export enumerate_segments_with_selector(
        sel_t selector,
        ea_t (idaapi *func)(segment_t *s, void *ud),
        void *ud=nullptr);
 

typedef std::function<ea_t(ea_t seg_start_ea)> segment_selector_visitor_t;
 

 
idaman ea_t ida_export enumerate_segments_with_selector_ea(
        sel_t selector,
        const segment_selector_visitor_t &visitor);
 

 
idaman DEPRECATED segment_t *ida_export get_segm_by_sel(sel_t selector);

 
idaman ea_t ida_export get_segment_ea_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 DEPRECATED bool ida_export add_segm_ex(
        segment_t *NONNULL s,
        const char *name,
        const char *sclass,
        int flags);

 
idaman bool ida_export add_segment_ex(segment_info_t *si, 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  
#define ADDSEG_KEEP_TYPE  0x0100  
 

 
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();
 

 
idaman DEPRECATED segment_t *ida_export getseg(ea_t ea);

#define GSI_NAME     0x0001  
#define GSI_SCLASS   0x0002  
#define GSI_CMT_REG  0x0004  
#define GSI_CMT_RPT  0x0008  
#define GSI_COMMENTS (GSI_CMT_REG|GSI_CMT_RPT) 
#define GSI_ALL      (GSI_NAME|GSI_SCLASS|GSI_COMMENTS) 
#define GSI_UPDATED  0x0100  

 
idaman bool ida_export get_segment_info(segment_info_t *out, ea_t ea, int flags=0);
 

 
idaman bool ida_export set_segment_info(segment_info_t *si, int flags=0);
 

 
idaman ea_t ida_export get_segment_ea(ea_t ea);
 

 
idaman DEPRECATED segment_t *ida_export getnseg(int n);

 
idaman bool ida_export get_segment_info_by_num(segment_info_t *out, int n, int flags=0);
 

 
idaman ea_t ida_export get_segment_ea_by_num(int n);
 

idaman int ida_export get_segm_num(ea_t ea);
 

idaman DEPRECATED segment_t *ida_export get_next_seg(ea_t ea);

 
idaman ea_t ida_export get_next_segment_ea(ea_t seg_ea);
 

idaman DEPRECATED segment_t *ida_export get_prev_seg(ea_t ea);

 
idaman ea_t ida_export get_prev_segment_ea(ea_t seg_ea);
 

idaman DEPRECATED segment_t *ida_export get_first_seg();

 
idaman ea_t ida_export get_first_segment_ea();
 

idaman DEPRECATED segment_t *ida_export get_last_seg();

 
idaman ea_t ida_export get_last_segment_ea();
 

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

 
idaman ea_t ida_export get_segment_ea_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 DEPRECATED move_segm_code_t ida_export move_segm(segment_t *s, ea_t to, int flags=0);

 
idaman move_segm_code_t ida_export move_segment(ea_t seg_ea, 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 DEPRECATED int ida_export change_segment_status(segment_t *s, bool is_deb_segm);

 
idaman int ida_export change_segment_status_by_ea(ea_t ea, 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();
 

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

 
idaman bool ida_export set_segment_base_ea(ea_t seg_ea, 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 DEPRECATED ssize_t ida_export get_segment_cmt(qstring *buf, const segment_t *s, bool repeatable);

 
idaman ssize_t ida_export get_segment_cmt_by_ea(qstring *buf, ea_t ea, bool repeatable);
 

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

 
idaman void ida_export set_segment_cmt_by_ea(ea_t ea, const char *cmt, bool repeatable);
 

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

 
idaman void ida_export std_out_segment_footer(struct outctx_t &ctx, ea_t seg_ea);

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

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

 
idaman int ida_export set_segment_name(ea_t ea, const char *name, int flags=0);
 

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

 
idaman ssize_t ida_export get_segment_name(qstring *buf, ea_t ea, int flags=0);
 

 
DEPRECATED inline ssize_t idaapi get_visible_segm_name(qstring *buf, const segment_t *s)
{
  return s != nullptr ? get_segment_name(buf, s->start_ea, 1) : -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 DEPRECATED ssize_t ida_export get_segm_class(qstring *buf, const segment_t *s);

 
idaman ssize_t ida_export get_segment_class(qstring *buf, ea_t ea);
 

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

 
idaman int ida_export set_segment_class(ea_t ea, 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 DEPRECATED ea_t ida_export get_segm_para(const segment_t *s);

 
idaman ea_t ida_export get_segment_para(ea_t ea);
 

 
idaman DEPRECATED ea_t ida_export get_segm_base(const segment_t *s);

 
idaman ea_t ida_export get_segment_base(ea_t ea);
 

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

 
idaman bool ida_export set_segment_addressing(ea_t ea, size_t bitness);
 

 
idaman bool ida_export is_same_segment(ea_t ea1, ea_t ea2);
 
 
ea_t segment_info_t::para() const { return sel2para(sel_); }
 
//-----------------------------------------------------------------------

 
inline bool is_debugger_segm(ea_t ea)
{
  segment_info_t si;
  return get_segment_info(&si, ea) && si.is_debugger_segm();
}

 
inline bool is_ephemeral_segm(ea_t ea)
{
  segment_info_t si;
  return get_segment_info(&si, ea) && si.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()
{
  return update_segm(this);
}

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

idaman adiff_t ida_export adjust_segment_diff(ea_t seg_ea, adiff_t delta);

idaman DEPRECATED ea_t ida_export segm_adjust_ea(const segment_t *s, ea_t ea);

idaman ea_t ida_export adjust_segment_ea(ea_t seg_ea, ea_t ea);
 
#endif // _SEGMENT_HPP