Module index

Module ida_segment

IDA Plugin SDK API wrapper: segment

Global variables

var ADDSEG_FILLGAP
fill gap between new segment and previous one. i.e. if such a gap exists, and this gap is less than 64K, then fill the gap by extending the previous segment and adding .align directive to it. This way we avoid gaps between segments. too many gaps lead to a virtual array failure. it cannot hold more than ~1000 gaps.
var ADDSEG_IDBENC
'name' and 'sclass' are given in the IDB encoding; non-ASCII bytes will be decoded accordingly
var ADDSEG_NOAA
do not mark new segment for auto-analysis
var ADDSEG_NOSREG
set all default segment register values to 'BADSEL' (undefine all default segment registers)
var ADDSEG_NOTRUNC
don't truncate the new segment at the beginning of the next segment if they overlap. destroy/truncate old segments instead.
var ADDSEG_OR_DIE
'qexit()' if can't add a segment
var ADDSEG_QUIET
silent mode, no "Adding segment..." in the messages window
var ADDSEG_SPARSE
use sparse storage method for the new ranges of the created segment. please note that the ranges that were already enabled before creating the segment will not change their storage type.
var CSS_BREAK
memory reading process stopped by user
var CSS_NODBG
debugger is not running
var CSS_NOMEM
not enough memory (might be because the segment is too big)
var CSS_NORANGE
could not find corresponding memory range
var CSS_OK
ok
var MAX_GROUPS
max number of segment groups
var MAX_SEGM_TRANSLATIONS
max number of segment translations
var MOVE_SEGM_CHUNK
Too many chunks are defined, can't move.
var MOVE_SEGM_DEBUG
Debugger segments cannot be moved.
var MOVE_SEGM_IDP
IDP module forbids moving the segment.
var MOVE_SEGM_LOADER
The segment has been moved but the loader complained.
var MOVE_SEGM_ODD
Cannot move segments by an odd number of bytes.
var MOVE_SEGM_OK
all ok
var MOVE_SEGM_ORPHAN
Orphan bytes hinder segment movement.
var MOVE_SEGM_PARAM
The specified segment does not exist.
var MOVE_SEGM_ROOM
Not enough free room at the target address.
var MSF_FIXONCE
call loader only once with the special calling method. valid for 'rebase_program()' . see 'loader_t::move_segm' .
var MSF_LDKEEP
keep the loader in the memory (optimization)
var MSF_NETNODES
move netnodes instead of changing inf.netdelta (this is slower) valid for 'rebase_program()'
var MSF_NOFIX
don't call the loader to fix relocations
var MSF_PRIORITY
loader segments will overwrite any existing debugger segments when moved. valid for 'move_segm()'
var MSF_SILENT
don't display a "please wait" box on the screen
var SEGMOD_KEEP
keep information (code & data, etc)
var SEGMOD_KEEP0
flag for internal use, don't set
var SEGMOD_KEEPSEL
do not try to delete unused selector
var SEGMOD_KILL
disable addresses if segment gets shrinked or deleted
var SEGMOD_NOMOVE
don't move info from the start of segment to the new start address (for 'set_segm_start()' )
var SEGMOD_SILENT
be silent
var SEGMOD_SPARSE
use sparse storage if extending the segment (for 'set_segm_start()' , 'set_segm_end()' )
var SEGPERM_EXEC
Execute.
var SEGPERM_MAXVAL
SEGPERM_MAXVAL = 7
var SEGPERM_READ
Read.
var SEGPERM_WRITE
Write.
var SEG_ABSSYM
segment with definitions of absolute symbols
var SEG_BSS
uninitialized segment
var SEG_CODE
code segment
var SEG_COMM
segment with communal definitions
var SEG_DATA
data segment
var SEG_GRP
group of segments
var SEG_IMEM
internal processor memory & sfr (8051)
var SEG_IMP
java: implementation segment
var SEG_MAX_BITNESS_CODE
SEG_MAX_BITNESS_CODE = 2
var SEG_MAX_SEGTYPE_CODE
SEG_MAX_SEGTYPE_CODE = 12
var SEG_NORM
unknown type, no assumptions
var SEG_NULL
zero-length segment
var SEG_UNDF
undefined segment type (not used)
var SEG_XTRN
segment with 'extern' definitions. no instructions are allowed
var SFL_COMORG
IDP dependent field (IBM PC: if set, ORG directive is not commented out)
var SFL_DEBUG
Is the segment created for the debugger?. Such segments are temporary and do not have permanent flags.
var SFL_HEADER
Header segment (do not create offsets to it in the disassembly)
var SFL_HIDDEN
Is the segment hidden?
var SFL_HIDETYPE
Hide segment type (do not print it in the listing)
var SFL_LOADER
Is the segment created by the loader?
var SFL_OBOK
Orgbase is present? (IDP dependent field)
var SREG_NUM
Maximum number of segment registers is 16 (see 'segregs.hpp' )
var saAbs
Absolute segment.
var saGroup
Segment group.
var saRel1024Bytes
1024 bytes
var saRel128Bytes
128 bytes
var saRel2048Bytes
2048 bytes
var saRel32Bytes
32 bytes
var saRel4K
This value is used by the PharLap OMF for page (4K) alignment. It is not supported by LINK.
var saRel512Bytes
512 bytes
var saRel64Bytes
64 bytes
var saRelByte
Relocatable, byte aligned.
var saRelDble
Relocatable, aligned on a double word (4-byte) boundary.
var saRelPage
Relocatable, aligned on 256-byte boundary.
var saRelPara
Relocatable, paragraph (16-byte) aligned.
var saRelQword
8 bytes
var saRelWord
Relocatable, word (2-byte) aligned.
var saRel_MAX_ALIGN_CODE
saRel_MAX_ALIGN_CODE = 14
var scCommon
Common. Combine by overlay using maximum size.
var scGroup
Segment group.
var scPriv
Private. Do not combine with any other program segment.
var scPub
Public. Combine by appending at an offset that meets the alignment requirement.
var scPub2
As defined by Microsoft, same as C=2 (public).
var scPub3
As defined by Microsoft, same as C=2 (public).
var scStack
Stack. Combine as for C=2. This combine type forces byte alignment.
var sc_MAX_COMB_CODE
sc_MAX_COMB_CODE = 7

Functions

def add_segm(*args) ‑> bool
Add a new segment, second form. Segment alignment is set to 'saRelByte' . Segment combination is "public" or "stack" (if segment class is "STACK"). Addressing mode of segment is taken as default (16bit or 32bit). Default segment registers are set to 'BADSEL' . If a segment already exists at the specified range of addresses, this segment will be truncated. Instructions and data in the old segment will be deleted if the new segment has another addressing mode or another segment base address.
add_segm(para, start, end, name, sclass, flags=0) -> bool
para: segment base paragraph. if paragraph can't fit in 16bit,
then a new selector is allocated and mapped to the paragraph. (C++: ea_t)
start: start address of the segment. if start== BADADDR then
start <- to_ea(para,0). (C++: ea_t)
end: end address of the segment. end address should be higher
than start address. For emulate empty segments, use SEG_NULL segment type. If the end address is lower than start address, then fail. If end== BADADDR , then a segment up to the next segment will be created (if the next segment doesn't exist, then 1 byte segment will be created). If 'end' is too high and the new segment would overlap the next segment, 'end' is adjusted properly. (C++: ea_t)
name: name of new segment. may be NULL (C++: const char *)
sclass: class of the segment. may be NULL. type of the new
segment is modified if class is one of predefined names: "CODE" -> SEG_CODE "DATA" -> SEG_DATA "CONST" -> SEG_DATA "STACK" -> SEG_BSS "BSS" -> SEG_BSS "XTRN" -> SEG_XTRN "COMM" -> SEG_COMM "ABS" -> SEG_ABSSYM (C++: const char *)
flags (C++: int)
retval: 1 - ok
retval: 0 - failed, a warning message is displayed
def add_segm_ex(*args) ‑> bool
Add a new segment. If a segment already exists at the specified range of addresses, this segment will be truncated. Instructions and data in the old segment will be deleted if the new segment has another addressing mode or another segment base address.
add_segm_ex(s, name, sclass, flags) -> bool
s: pointer to filled segment structure. segment
selector should have proper mapping (see set_selector() ). if s.start_ea== BADADDR then s.start_ea <- get_segm_base(&s) if s.end_ea== BADADDR , then a segment up to the next segment will be created (if the next segment doesn't exist, then 1 byte segment will be created). if the s.end_ea < s.start_ea, then fail. if s.end_ea is too high and the new segment would overlap the next segment, s.end_ea is adjusted properly. (C++: segment_t *)
name: name of new segment. may be NULL. if specified, the
segment is immediately renamed (C++: const char *)
sclass: class of the segment. may be NULL. if specified, the
segment class is immediately changed (C++: const char *)
flags: Add segment flags (C++: int)
retval: 1 - ok
retval: 0 - failed, a warning message is displayed
def add_segment_translation(*args) ‑> bool
Add segment translation.
add_segment_translation(segstart, mappedseg) -> bool
segstart: start address of the segment to add translation to
(C++: ea_t)
mappedseg: start address of the overlayed segment (C++: ea_t)
retval: 1 - ok
retval: 0 - too many translations or bad segstart
def allocate_selector(*args) ‑> sel_t
Allocate a selector for a segment unconditionally. You must call this function before calling 'add_segm_ex()' . 'add_segm()' calls this function itself, so you don't need to allocate a selector. This function will allocate a new free selector and setup its mapping using 'find_free_selector()' and 'set_selector()' functions.
allocate_selector(segbase) -> sel_t
segbase: a new segment base paragraph (C++: ea_t)
return: the allocated selector number
def change_segment_status(*args) ‑> int
Convert a debugger segment to a regular segment and vice versa. When converting debug->regular, the memory contents will be copied to the database.
change_segment_status(s, is_deb_segm) -> int
s: segment to modify (C++: segment_t *)
is_deb_segm: new status of the segment (C++: bool)
return: Change segment status result codes
def del_segm(*args) ‑> bool
Delete a segment.
del_segm(ea, flags) -> bool
ea: any address belonging to the segment (C++: ea_t)
flags: Segment modification flags (C++: int)
retval: 1 - ok
retval: 0 - failed, no segment at 'ea'.
def del_segment_translations(*args) ‑> void
Delete the translation list
del_segment_translations(segstart)
segstart: start address of the segment to delete translation
list (C++: ea_t)
def del_selector(*args) ‑> void
Delete mapping of a selector. Be wary of deleting selectors that are being used in the program, this can make a mess in the segments.
del_selector(selector)
selector: number of selector to remove from the translation
table (C++: sel_t)
def find_free_selector(*args) ‑> sel_t
Find first unused selector.
def find_selector(*args) ‑> sel_t
Find a selector that has mapping to the specified paragraph.
find_selector(base) -> sel_t
base: paragraph to search in the translation table (C++: ea_t)
return: selector value or base
def get_defsr(*args) ‑> sel_t
get_defsr(s, reg) -> sel_t
s: segment_t * reg: int
def get_first_seg(*args) ‑> segment_t *
Get pointer to the first segment.
def get_group_selector(*args) ‑> sel_t
Get common selector for a group of segments.
get_group_selector(grpsel) -> sel_t
grpsel: selector of group segment (C++: sel_t)
return: common selector of the group or 'grpsel' if no such group is
found
def get_last_seg(*args) ‑> segment_t *
Get pointer to the last segment.
def get_next_seg(*args) ‑> segment_t *
Get pointer to the next segment.
get_next_seg(ea) -> segment_t
ea (C++: ea_t)
def get_prev_seg(*args) ‑> segment_t *
Get pointer to the previous segment.
get_prev_seg(ea) -> segment_t
ea (C++: ea_t)
def get_segm_base(*args) ‑> ea_t
Get segment base linear address. Segment base linear address is used to calculate virtual addresses. The virtual address of the first byte of the segment will be (start address of segment - segment base linear address)
get_segm_base(s) -> ea_t
s: pointer to segment (C++: const segment_t *)
return: 0 if s == NULL, otherwise segment base linear address
def get_segm_by_name(*args) ‑> segment_t *
Get pointer to segment by its name. If there are several segments with the same name, returns the first of them.
get_segm_by_name(name) -> segment_t
name: segment name. may be NULL. (C++: const char *)
return: NULL or pointer to segment structure
def get_segm_by_sel(*args) ‑> segment_t *
Get pointer to segment structure. This function finds a segment by its selector. If there are several segments with the same selectors, the last one will be returned.
get_segm_by_sel(selector) -> segment_t
selector: a segment with the specified selector will be
returned (C++: sel_t)
return: pointer to segment or NULL
def get_segm_class(*args) ‑> qstring *
Get segment class. Segment class is arbitrary text (max 8 characters).
get_segm_class(s) -> str
s: pointer to segment (C++: const segment_t *)
return: size of segment class (-1 if s==NULL or bufsize<=0)
def get_segm_name(*args) ‑> qstring *
Get true segment name by pointer to segment.
get_segm_name(s, flags=0) -> str
s: pointer to segment (C++: const segment_t *)
flags: 0-return name as is; 1-substitute bad symbols with _ 1
corresponds to GN_VISIBLE (C++: int)
return: size of segment name (-1 if s==NULL)
def get_segm_num(*args) ‑> int
Get number of segment by address.
get_segm_num(ea) -> int
ea: linear address belonging to the segment (C++: ea_t)
return: -1 if no segment occupies the specified address. otherwise
returns number of the specified segment (0.. get_segm_qty() -1)
def get_segm_para(*args) ‑> ea_t
Get segment base paragraph. Segment base paragraph may be converted to segment base linear address using 'to_ea()' function. In fact, to_ea(get_segm_para(s), 0) == get_segm_base(s).
get_segm_para(s) -> ea_t
s: pointer to segment (C++: const segment_t *)
return: 0 if s == NULL, the segment base paragraph
def get_segm_qty(*args) ‑> int
Get number of segments.
def get_segment_alignment(*args) ‑> char const *
Get text representation of segment alignment code.
get_segment_alignment(align) -> char const *
align (C++: uchar)
return: text digestable by IBM PC assembler.
def get_segment_cmt(*args) ‑> qstring *
Get segment comment.
get_segment_cmt(s, repeatable) -> str
s: pointer to segment structure (C++: const segment_t *)
repeatable: 0: get regular comment. 1: get repeatable comment.
(C++: bool)
return: size of comment or -1
def get_segment_combination(*args) ‑> char const *
Get text representation of segment combination code.
get_segment_combination(comb) -> char const *
comb (C++: uchar)
return: text digestable by IBM PC assembler.
def get_segment_translations(*args) ‑> ssize_t
Get segment translation list.
get_segment_translations(transmap, segstart) -> ssize_t
transmap: vector of segment start addresses for the translation
list (C++: eavec_t *)
segstart: start address of the segment to get information about
(C++: ea_t)
return: -1 if no translation list or bad segstart. otherwise returns
size of translation list.
def get_selector_qty(*args) ‑> size_t
Get number of defined selectors.
def get_visible_segm_name(*args) ‑> qstring *
Get segment name by pointer to segment.
get_visible_segm_name(s) -> str
s: pointer to segment (C++: const segment_t *)
return: size of segment name (-1 if s==NULL)
def getn_selector(*args) ‑> sel_t *, ea_t *
Get description of selector (0.. 'get_selector_qty()' -1)
getn_selector(n) -> bool
n (C++: int)
def getnseg(*args) ‑> segment_t *
Get pointer to segment by its number.Obsoleted because it can slow down the debugger (it has to refresh the whole memory segmentation to calculate the correct answer)
getnseg(n) -> segment_t
n: segment number in the range (0.. get_segm_qty() -1) (C++:
int)
return: NULL or pointer to segment structure
def getseg(*args) ‑> segment_t *
Get pointer to segment by linear address.
getseg(ea) -> segment_t
ea: linear address belonging to the segment (C++: ea_t)
return: NULL or pointer to segment structure
def is_finally_visible_segm(*args) ‑> bool
See 'SFL_HIDDEN' , 'SCF_SHHID_SEGM' .
is_finally_visible_segm(s) -> bool
s (C++: segment_t *)
def is_miniidb(*args) ‑> bool
Is the database a miniidb created by the debugger?.
def is_segm_locked(*args) ‑> bool
Is a segment pointer locked?
is_segm_locked(segm) -> bool
segm (C++: const segment_t *)
def is_spec_ea(*args) ‑> bool
Does the address belong to a segment with a special type?. ( 'SEG_XTRN' , 'SEG_GRP' , 'SEG_ABSSYM' , 'SEG_COMM' )
is_spec_ea(ea) -> bool
ea: linear address (C++: ea_t)
def is_spec_segm(*args) ‑> bool
Has segment a special type?. ( 'SEG_XTRN' , 'SEG_GRP' , 'SEG_ABSSYM' , 'SEG_COMM' )
is_spec_segm(seg_type) -> bool
seg_type (C++: uchar)
def is_visible_segm(*args) ‑> bool
See 'SFL_HIDDEN' .
is_visible_segm(s) -> bool
s (C++: segment_t *)
def lock_segm(*args) ‑> void
Lock segment pointer Locked pointers are guaranteed to remain valid until they are unlocked. Ranges with locked pointers cannot be deleted or moved.
lock_segm(segm, lock)
segm (C++: const segment_t *)
lock (C++: bool)
def move_segm(*args) ‑> int
Move a segment to a new address. This function moves all information to the new address. It fixes up address sensitive information in the kernel. The total effect is equal to reloading the segment to the target address. For the file format dependent address sensitive information, 'loader_t::move_segm' is called. Also IDB notification event 'idb_event::segm_moved' is called.
move_segm(s, to, flags=0) -> int
s: segment to move (C++: segment_t *)
to: new segment start address (C++: ea_t)
flags: Move segment flags (C++: int)
return: Move segment result codes
def move_segm_start(*args) ‑> bool
Move segment start. The main difference between this function and 'set_segm_start()' is that this function may expand the previous segment while 'set_segm_start()' never does it. So, this function allows to change bounds of two segments simultaneously. If the previous segment and the specified segment have the same addressing mode and segment base, then instructions and data are not destroyed - they simply move from one segment to another. Otherwise all instructions/data which migrate from one segment to another are destroyed.this function never disables addresses.
move_segm_start(ea, newstart, mode) -> bool
ea: any address belonging to the segment (C++: ea_t)
newstart: new start address of the segment note that segment
start address should be higher than segment base linear address. (C++: ea_t)
mode: policy for destroying defined items 0: if it is
necessary to destroy defined items, display a dialog box and ask confirmation 1: if it is necessary to destroy defined items, just destroy them without asking the user -1: if it is necessary to destroy defined items, don't destroy them (i.e. function will fail) -2: don't destroy defined items (function will succeed) (C++: int)
retval: 1 - ok
retval: 0 - failed, a warning message is displayed
def rebase_program(*args) ‑> int
Rebase the whole program by 'delta' bytes.
rebase_program(delta, flags) -> int
delta: number of bytes to move the program (C++: adiff_t)
flags: Move segment flags it is recommended to use
MSF_FIXONCE so that the loader takes care of global variables it stored in the database (C++: int)
return: Move segment result codes
def segm_adjust_diff(*args) ‑> adiff_t
Truncate and sign extend a delta depending on the segment.
segm_adjust_diff(s, delta) -> adiff_t
s (C++: const segment_t *)
delta (C++: adiff_t)
def segm_adjust_ea(*args) ‑> ea_t
Truncate an address depending on the segment.
segm_adjust_ea(s, ea) -> ea_t
s (C++: const segment_t *)
ea (C++: ea_t)
def segtype(*args) ‑> uchar
Get segment type.
segtype(ea) -> uchar
ea: any linear address within the segment (C++: ea_t)
return: Segment types , SEG_UNDF if no segment found at 'ea'
def sel2ea(*args) ‑> ea_t
Get mapping of a selector as a linear address.
sel2ea(selector) -> ea_t
selector: number of selector to translate to linear address
(C++: sel_t)
return: linear address the specified selector is mapped to. if there
is no mapping, returns to_ea(selector,0);
def sel2para(*args) ‑> ea_t
Get mapping of a selector.
sel2para(selector) -> ea_t
selector: number of selector to translate (C++: sel_t)
return: paragraph the specified selector is mapped to. if there is no
mapping, returns 'selector'.
def set_defsr(*args) ‑> void
set_defsr(s, reg, value)
s: segment_t * reg: int value: sel_t
def set_group_selector(*args) ‑> int
Create a new group of segments (used OMF files).
set_group_selector(grp, sel) -> int
grp: selector of group segment (segment type is SEG_GRP ) You
should create an 'empty' (1 byte) group segment It won't contain anything and will be used to redirect references to the group of segments to the common selector. (C++: sel_t)
sel: common selector of all segments belonging to the segment
You should create all segments within the group with the same selector value. (C++: sel_t)
return: 1 ok
def set_segm_addressing(*args) ‑> bool
Change segment addressing mode (16, 32, 64 bits). You must use this function to change segment addressing, never change the 'bitness' field directly. This function will delete all instructions, comments and names in the segment
set_segm_addressing(s, bitness) -> bool
s: pointer to segment (C++: segment_t *)
bitness: new addressing mode of segment 2: 64bit segment 1:
32bit segment 0: 16bit segment (C++: size_t)
return: success
def set_segm_base(*args) ‑> bool
Internal function.
set_segm_base(s, newbase) -> bool
s (C++: segment_t *)
newbase (C++: ea_t)
def set_segm_class(*args) ‑> int
Set segment class.
set_segm_class(s, sclass, flags=0) -> int
s: pointer to segment (may be NULL) (C++: segment_t *)
sclass: segment class (may be NULL). If segment type is
SEG_NORM and segment class is one of predefined names, then segment type is changed to: "CODE" -> SEG_CODE "DATA" -> SEG_DATA "STACK" -> SEG_BSS "BSS" -> SEG_BSS if "UNK" then segment type is reset to SEG_NORM . (C++: const char *)
flags (C++: int)
retval: 1 - ok, name is good and segment is renamed
retval: 0 - failure, name is NULL or bad or segment is NULL
def set_segm_end(*args) ‑> bool
Set segment end address. The next segment is shrinked to allow expansion of the specified segment. The kernel might even delete the next segment if necessary. The kernel will ask the user for a permission to destroy instructions or data going out of segment scope if such instructions exist.
set_segm_end(ea, newend, flags) -> bool
ea: any address belonging to the segment (C++: ea_t)
newend: new end address of the segment (C++: ea_t)
flags: Segment modification flags (C++: int)
retval: 1 - ok
retval: 0 - failed, a warning message is displayed
def set_segm_name(*args) ‑> int
Rename segment. The new name is validated (see validate_name). A segment always has a name. If you hadn't specified a name, the kernel will assign it "seg###" name where ### is segment number.
set_segm_name(s, name, flags=0) -> int
s: pointer to segment (may be NULL) (C++: segment_t *)
name: new segment name (C++: const char *)
flags: ADDSEG_IDBENC or 0 (C++: int)
retval: 1 - ok, name is good and segment is renamed
retval: 0 - failure, name is bad or segment is NULL
def set_segm_start(*args) ‑> bool
Set segment start address. The previous segment is trimmed to allow expansion of the specified segment. The kernel might even delete the previous segment if necessary. The kernel will ask the user for a permission to destroy instructions or data going out of segment scope if such instructions exist.
set_segm_start(ea, newstart, flags) -> bool
ea: any address belonging to the segment (C++: ea_t)
newstart: new start address of the segment note that segment
start address should be higher than segment base linear address. (C++: ea_t)
flags: Segment modification flags (C++: int)
retval: 1 - ok
retval: 0 - failed, a warning message is displayed
def set_segment_cmt(*args) ‑> void
Set segment comment.
set_segment_cmt(s, cmt, repeatable)
s: pointer to segment structure (C++: const segment_t *)
cmt: comment string, may be multiline (with ' '). maximal size
is 4096 bytes. Use empty str ("") to delete comment (C++: const char *)
repeatable: 0: set regular comment. 1: set repeatable comment.
(C++: bool)
def set_segment_translations(*args) ‑> bool
Set new translation list.
set_segment_translations(segstart, transmap) -> bool
segstart: start address of the segment to add translation to
(C++: ea_t)
transmap: vector of segment start addresses for the translation
list. If transmap is empty, the translation list is deleted. (C++: const eavec_t &)
retval: 1 - ok
retval: 0 - too many translations or bad segstart
def set_selector(*args) ‑> int
Set mapping of selector to a paragraph. You should call this functionbeforecreating a segment which uses the selector, otherwise the creation of the segment will fail.
set_selector(selector, paragraph) -> int
selector: number of selector to map if selector == BADSEL ,
then return 0 (fail) if the selector has had a mapping, old mapping is destroyed if the selector number is equal to paragraph value, then the mapping is destroyed because we don't need to keep trivial mappings. (C++: sel_t)
paragraph: paragraph to map selector (C++: ea_t)
retval: 1 - ok
retval: 0 - failure (bad selector or too many mappings)
def set_visible_segm(*args) ‑> void
See 'SFL_HIDDEN' .
set_visible_segm(s, visible)
s (C++: segment_t *)
visible (C++: bool)
def setup_selector(*args) ‑> sel_t
Allocate a selector for a segment if necessary. You must call this function before calling 'add_segm_ex()' . 'add_segm()' calls this function itself, so you don't need to allocate a selector. This function will allocate a selector if 'segbase' requires more than 16 bits and the current processor is IBM PC. Otherwise it will return the segbase value.
setup_selector(segbase) -> sel_t
segbase: a new segment base paragraph (C++: ea_t)
return: the allocated selector number
Generate segment footer line as a comment line. This function may be used in IDP modules to generate segment footer if the target assembler doesn't have 'ends' directive.
std_out_segm_footer(ctx, seg)
ctx (C++: struct outctx_t &)
seg (C++: segment_t *)
def take_memory_snapshot(*args) ‑> bool
Take a memory snapshot of the running process.
take_memory_snapshot(only_loader_segs) -> bool
only_loader_segs: only is_loader_segm() segments will be
affected (C++: bool)
return: success
def update_segm(*args) ‑> bool
update_segm(s) -> bool
s (C++: segment_t *)

Classes

class lock_segment (*args)
Proxy of C++ lock_segment class.
__init__(self, _segm) -> lock_segment
_segm: segment_t const *
class segment_t (*args)
Proxy of C++ segment_t class.
__init__(self) -> segment_t

Ancestors

Instance variables

var align
segment_t_align_get(self) -> uchar
var bitness
segment_t_bitness_get(self) -> uchar
var color
segment_t_color_get(self) -> bgcolor_t
var comb
segment_t_comb_get(self) -> uchar
var defsr
segment_t_defsr_get(self) -> sel_t [16]
var end_ea
segment_t_end_ea_get(self) -> ea_t
var flags
segment_t_flags_get(self) -> ushort
var name
segment_t_name_get(self) -> uval_t
var orgbase
segment_t_orgbase_get(self) -> uval_t
var perm
segment_t_perm_get(self) -> uchar
var sclass
segment_t_sclass_get(self) -> uval_t
var sel
segment_t_sel_get(self) -> sel_t
var start_ea
segment_t_start_ea_get(self) -> ea_t
var type
segment_t_type_get(self) -> uchar

Methods

def abits(self, *args) ‑> int
Get number of address bits.
def abytes(self, *args) ‑> int
Get number of address bytes.
def clr_comorg(self, *args) ‑> void
clr_comorg(self)
def clr_ob_ok(self, *args) ‑> void
clr_ob_ok(self)
def comorg(self, *args) ‑> bool
comorg(self) -> bool
def is_16bit(self, *args) ‑> bool
Is a 16-bit segment?
def is_32bit(self, *args) ‑> bool
Is a 32-bit segment?
def is_64bit(self, *args) ‑> bool
Is a 64-bit segment?
def is_header_segm(self, *args) ‑> bool
is_header_segm(self) -> bool
def is_hidden_segtype(self, *args) ‑> bool
is_hidden_segtype(self) -> bool
def is_loader_segm(self, *args) ‑> bool
is_loader_segm(self) -> bool
def is_visible_segm(self, *args) ‑> bool
is_visible_segm(self) -> bool
def ob_ok(self, *args) ‑> bool
ob_ok(self) -> bool
def set_comorg(self, *args) ‑> void
set_comorg(self)
def set_debugger_segm(self, *args) ‑> void
set_debugger_segm(self, debseg)
debseg: bool
def set_header_segm(self, *args) ‑> void
set_header_segm(self, on)
on: bool
def set_hidden_segtype(self, *args) ‑> void
set_hidden_segtype(self, hide)
hide: bool
def set_loader_segm(self, *args) ‑> void
set_loader_segm(self, ldrseg)
ldrseg: bool
def set_ob_ok(self, *args) ‑> void
set_ob_ok(self)
def set_visible_segm(self, *args) ‑> void
set_visible_segm(self, visible)
visible: bool
def update(self, *args) ‑> bool
Update segment information. You must call this function after modification of segment characteristics. Note that not all fields of segment structure may be modified directly, there are special functions to modify some fields.
def use64(self, *args) ‑> bool
Is a 64-bit segment?

Inherited members