Detailed Description

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
idaman reftype_t ida_export	get_default_reftype (ea_t ea)
	Get default reference type depending on the segment. More...

idaman bool ida_export	op_offset_ex (ea_t ea, int n, const refinfo_t *ri)
	Convert operand to a reference. More...

idaman bool ida_export	op_offset (ea_t ea, int n, uint32 type_and_flags, ea_t target=BADADDR, ea_t base=0, adiff_t tdelta=0)
	See op_offset_ex()

bool	op_plain_offset (ea_t ea, int n, ea_t base)
	Convert operand to a reference with the default reference type.

ea_t	get_offbase (ea_t ea, int n)
	Get offset base value. More...

idaman int ida_export	get_offset_expression (qstring *buf, ea_t ea, int n, ea_t from, adiff_t offset, int getn_flags=0)
	Get offset expression (in the form "offset name+displ"). More...

idaman int ida_export	get_offset_expr (qstring *buf, ea_t ea, int n, const refinfo_t &ri, ea_t from, adiff_t offset, int getn_flags=0)
	See get_offset_expression()

idaman ea_t ida_export	can_be_off32 (ea_t ea)
	Does the specified address contain a valid OFF32 value?. More...

idaman ea_t ida_export	calc_offset_base (ea_t ea, int n)
	Try to calculate the offset base This function takes into account the fixup information, current ds and cs values. More...

idaman ea_t ida_export	calc_probable_base_by_value (ea_t ea, uval_t off)
	Try to calculate the offset base. More...

idaman bool ida_export	calc_reference_data (ea_t target, ea_t base, ea_t from, const refinfo_t &ri, adiff_t opval)
	Calculate the target and base addresses of an offset expression. More...

idaman ea_t ida_export	add_refinfo_dref (const insn_t &insn, ea_t from, const refinfo_t &ri, adiff_t opval, dref_t type, int opoff)
	Add xrefs for a reference from the given instruction (\insn_t{ea}). More...

ea_t	calc_target (ea_t from, adiff_t opval, const refinfo_t &ri)
	Calculate the target using the provided refinfo_t.

ea_t	calc_target (ea_t from, ea_t ea, int n, adiff_t opval)
	Retrieve refinfo_t structure and calculate the target.

ea_t	calc_basevalue (ea_t target, ea_t base)
	Calculate the value of the reference base.

Function Documentation

◆ get_default_reftype()

idaman reftype_t ida_export get_default_reftype ( ea_t ea )

Get default reference type depending on the segment.

Returns: one of REF_OFF8, REF_OFF16, REF_OFF32, REF_OFF64

◆ op_offset_ex()

idaman bool ida_export op_offset_ex	(	ea_t	ea,
		int	n,
		const refinfo_t *	ri
	)

Convert operand to a reference.

To delete an offset, use clr_op_type() function.

Parameters

ea	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	operand number (may be ORed with OPND_OUTER) 0: first 1: second ... 7: eighth operand OPND_MASK: all operands
ri	reference information

Returns: success

◆ get_offbase()

ea_t get_offbase	(	ea_t	ea,
		int	n
	)

inline

Get offset base value.

Parameters

ea	linear address
n	0..UA_MAXOP-1 operand number

Returns: offset base or BADADDR

◆ get_offset_expression()

idaman int ida_export get_offset_expression	(	qstring *	buf,
		ea_t	ea,
		int	n,
		ea_t	from,
		adiff_t	offset,
		int	getn_flags = `0`
	)

Get 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 a colored string:

offset array

Parameters

buf	output buffer to hold offset expression
ea	start of instruction or data with the offset expression
n	operand number (may be ORed with OPND_OUTER) 0: first operand 1: second operand ... 7: eighth operand
from	linear address of instruction operand or data referring to the name. This address will be used to get fixup information, so it should point to exact position of operand in the instruction.
offset	value of operand or its part. The function will return text representation of this value as offset expression.
getn_flags	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)

Return values

0	can't convert to offset expression
1	ok, a simple offset expression
2	ok, a complex offset expression

◆ can_be_off32()

idaman ea_t ida_export can_be_off32 ( ea_t ea )

Does 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.

◆ calc_offset_base()

idaman ea_t ida_export calc_offset_base	(	ea_t	ea,
		int	n
	)

Try to calculate the offset base This function takes into account the fixup information, current ds and cs values.

Parameters

ea	the referencing instruction/data address
n	operand number 0: first operand 1: second operand ... 7: eighth operand

Returns: output base address or BADADDR

◆ calc_probable_base_by_value()

idaman ea_t ida_export calc_probable_base_by_value	(	ea_t	ea,
		uval_t	off
	)

Try to calculate the offset base.

2 bases are checked: current ds and cs. If fails, return BADADDR

◆ calc_reference_data()

idaman bool ida_export calc_reference_data	(	ea_t *	target,
		ea_t *	base,
		ea_t	from,
		const refinfo_t &	ri,
		adiff_t	opval
	)

Calculate 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.

Parameters

target	output target address
base	output base address
from	the referencing instruction/data address
ri	reference info block from the database
opval	operand value (usually op_t::value or op_t::addr)

Returns: success

◆ add_refinfo_dref()

idaman ea_t ida_export add_refinfo_dref	(	const insn_t &	insn,
		ea_t	from,
		const refinfo_t &	ri,
		adiff_t	opval,
		dref_t	type,
		int	opoff
	)

Add 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.

Parameters

insn	the referencing instruction
from	the referencing instruction/data address
ri	reference info block from the database
opval	operand value (usually op_t::value or op_t::addr)
type	type of xref
opoff	offset of the operand from the start of instruction

Returns: the target address of the reference