Module ida_offset
Functions that deal with offsets.
"Being an offset" is a characteristic of an operand. This means that operand or
its part represent offset from some address in the program. This linear address
is called "offset base". Some operands may have 2 offsets simultaneously.
Generally, IDA doesn't handle this except for Motorola outer offsets. Thus there
may be two offset values in an operand: simple offset and outer offset.
Outer offsets are handled by specifying special operand number: it should be
ORed with OPND_OUTER value.
See bytes.hpp for further explanation of operand numbers.
Functions
def add_refinfo_dref(*args) ‑> ea_t
-
add_refinfo_dref(insn, _from, ri, opval, type, opoff) -> ea_tAdd xrefs for a reference from the given instruction ( insn_t::ea). This function creates a cross references to the target and the base. insn_t::add_off_drefs() calls this function to create xrefs for 'offset' operand.insn: (C++: const insn_t &) the referencing instructionfrom: (C++: ea_t) the referencing instruction/data addressri: (C++: const refinfo_t &) reference info block from the databaseopval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr)type: (C++: dref_t) type of xrefopoff: (C++: int) offset of the operand from the start of instructionreturn: the target address of the reference
def calc_basevalue(*args) ‑> ea_t
-
calc_basevalue(target, base) -> ea_tCalculate the value of the reference base.target: (C++: ea_t)base: (C++: ea_t)
def calc_offset_base(*args) ‑> ea_t
-
calc_offset_base(ea, n) -> ea_tTry to calculate the offset base This function takes into account the fixup information, current ds and cs values.ea: (C++: ea_t) the referencing instruction/data addressn: (C++: int) operand number
- 0: first operand
- 1: second operand
- ...
- 7: eighth operand
return: output base address or BADADDR def calc_probable_base_by_value(*args) ‑> ea_t
-
calc_probable_base_by_value(ea, off) -> ea_tTry to calculate the offset base. 2 bases are checked: current ds and cs. If fails, return BADADDRea: (C++: ea_t)off: (C++: uval_t)
def calc_reference_data(*args) ‑> bool
-
calc_reference_data(target, base, _from, ri, opval) -> boolCalculate the target and base addresses of an offset expression. The calculated target and base addresses are returned in the locations pointed by 'base' and 'target'. In case 'ri.base' is BADADDR, the function calculates the offset base address from the referencing instruction/data address. The target address is copied from ri.target. If ri.target is BADADDR then the target is calculated using the base address and 'opval'. This function also checks if 'opval' matches the full value of the reference and takes in account the memory-mapping.target: (C++: ea_t *) output target addressbase: (C++: ea_t *) output base addressfrom: (C++: ea_t) the referencing instruction/data addressri: (C++: const refinfo_t &) reference info block from the databaseopval: (C++: adiff_t) operand value (usually op_t::value or op_t::addr)return: success
def calc_target(*args) ‑> ea_t
-
calc_target(_from, opval, ri) -> ea_tRetrieve refinfo_t structure and calculate the target.from: (C++: ea_t)opval: (C++: adiff_t)ri: refinfo_t const &calc_target(_from, ea, n, opval) -> ea_tfrom: ea_tea: ea_tn: intopval: adiff_t
def can_be_off32(*args) ‑> ea_t
-
can_be_off32(ea) -> ea_tDoes the specified address contain a valid OFF32 value?. For symbols in special segments the displacement is not taken into account. If yes, then the target address of OFF32 will be returned. If not, then BADADDR is returned.ea: (C++: ea_t)
def get_default_reftype(*args) ‑> reftype_t
-
get_default_reftype(ea) -> reftype_tGet default reference type depending on the segment.ea: (C++: ea_t)return: one of REF_OFF8, REF_OFF16, REF_OFF32, REF_OFF64
def get_offbase(*args) ‑> ea_t
-
get_offbase(ea, n) -> ea_tGet offset base valueea: (C++: ea_t) linear addressn: (C++: int) 0..UA_MAXOP-1 operand numberreturn: offset base or BADADDR
def get_offset_expr(*args) ‑> qstring *
-
get_offset_expr(ea, n, ri, _from, offset, getn_flags=0) -> strSee get_offset_expression()ea: (C++: ea_t)n: (C++: int)ri: (C++: const refinfo_t &) refinfo_t const &from: (C++: ea_t)offset: (C++: adiff_t)getn_flags: (C++: int)
def get_offset_expression(*args) ‑> qstring *
-
get_offset_expression(ea, n, _from, offset, getn_flags=0) -> strGet offset expression (in the form "offset name+displ"). This function uses offset translation function ( processor_t::translate) if your IDP module has such a function. Translation function is used to map linear addresses in the program (only for offsets).Example: suppose we have instruction at linear address 0x00011000: mov ax, [bx+7422h] and at ds:7422h: array dw ... We want to represent the second operand with an offset expression, so then we call: get_offset_expresion(0x001100, 1, 0x001102, 0x7422, buf);| | | | | | | | | +output buffer | | | +value of offset expression | | +address offset value in the instruction | +the second operand +address of instruction and the function will return acolored string: offset arrayea: (C++: ea_t) start of instruction or data with the offset expressionn: (C++: int) operand number (may be ORed with OPND_OUTER)
- 0: first operand
- 1: second operand
- ...
- 7: eighth operand
from: (C++: ea_t) linear address of instruction operand or data referring to thename. This address will be used to get fixup information, so it should point to exact position of operand in the instruction.offset: (C++: adiff_t) value of operand or its part. The function will return textrepresentation of this value as offset expression.getn_flags: (C++: int) combination of:- GETN_APPZERO: meaningful only if the name refers to a structure. appends the struct field name if the field offset is zero
- GETN_NODUMMY: do not generate dummy names for the expression but pretend they already exist (useful to verify that the offset expression can be represented)
retval 0: can't convert to offset expressionretval 1: ok, a simple offset expressionretval 2: ok, a complex offset expression def op_offset(*args) ‑> bool
-
op_offset(ea, n, type_and_flags, target=BADADDR, base=0, tdelta=0) -> boolSee op_offset_ex()ea: (C++: ea_t)n: (C++: int)type_and_flags: (C++: uint32)target: (C++: ea_t)base: (C++: ea_t)tdelta: (C++: adiff_t)
def op_offset_ex(*args) ‑> bool
-
op_offset_ex(ea, n, ri) -> boolConvert operand to a reference. To delete an offset, use clr_op_type() function.ea: (C++: ea_t) linear address. if 'ea' has unexplored bytes, try to convert them to
- no segment: fail
- 16bit segment: to 16bit word data
- 32bit segment: to dword
n: (C++: int) operand number (may be ORed with OPND_OUTER)- 0: first
- 1: second
- ...
- 7: eighth operand
- OPND_MASK: all operands
ri: (C++: const refinfo_t *) reference informationreturn: success def op_plain_offset(*args) ‑> bool
-
op_plain_offset(ea, n, base) -> boolConvert operand to a reference with the default reference type.ea: (C++: ea_t)n: (C++: int)base: (C++: ea_t)