Module index

# Module `ida_fixup`

Functions that deal with fixup information.

A loader should setup fixup information using set_fixup().

## Global variables

`var FIXUPF_CREATED`

  fixup was not present in the input file

`var FIXUPF_EXTDEF`

  target is a location (otherwise - segment). Use this bit if the target is a symbol rather than an offset from the beginning of a segment.

`var FIXUPF_LOADER_MASK`

  additional flags. The bits from this mask are not stored in the database and can be used by the loader at its discretion.

`var FIXUPF_REL`

  fixup is relative to the linear address `base`. Otherwise fixup is relative to the start of the segment with `sel` selector.

`var FIXUPF_UNUSED`

  fixup is ignored by IDA * disallows the kernel to convert operands * this fixup is not used during output

`var FIXUP_CUSTOM`

  start of the custom types range

`var FIXUP_HI16`

  high 16 bits of 32bit offset

`var FIXUP_HI8`

  high 8 bits of 16bit offset

`var FIXUP_LOW16`

  low 16 bits of 32bit offset

`var FIXUP_LOW8`

  low 8 bits of 16bit offset

`var FIXUP_OFF16`

  16-bit offset

`var FIXUP_OFF16S`

  16-bit signed offset

`var FIXUP_OFF32`

  32-bit offset

`var FIXUP_OFF32S`

  32-bit signed offset

`var FIXUP_OFF64`

  64-bit offset

`var FIXUP_OFF8`

  8-bit offset

`var FIXUP_OFF8S`

  8-bit signed offset

`var FIXUP_PTR16`

  32-bit long pointer (16-bit base:16-bit offset)

`var FIXUP_PTR32`

  48-bit pointer (16-bit base:32-bit offset)

`var FIXUP_SEG16`

  16-bit base-logical segment base (selector)

`var V695_FIXUP_VHIGH`

  obsolete

`var V695_FIXUP_VLOW`

  obsolete

## Functions

`def calc_fixup_size(type: fixup_type_t)`

  calc_fixup_size(type) -> int Calculate size of fixup in bytes (the number of bytes the fixup patches) @retval -1: means error

  @param type: (C++: fixup_type_t)

`def contains_fixups(ea: ea_t, size: asize_t)`

  contains_fixups(ea, size) -> bool Does the specified address range contain any fixup information?

  @param ea: (C++: ea_t) @param size: (C++: asize_t)

`def del_fixup(source: ea_t)`

  del_fixup(source) Delete fixup information.

  @param source: (C++: ea_t)

`def exists_fixup(source: ea_t)`

  exists_fixup(source) -> bool Check that a fixup exists at the given address.

  @param source: (C++: ea_t)

`def find_custom_fixup(name: char const *)`

  find_custom_fixup(name) -> fixup_type_t Get id of a custom fixup handler.

  @param name: (C++: const char *) name of the custom fixup handler @return: id with FIXUP_CUSTOM bit set or 0

`def gen_fix_fixups(_from: ea_t, to: ea_t, size: asize_t)`

  gen_fix_fixups(_from, to, size) Relocate the bytes with fixup information once more (generic function). This function may be called from loader_t::move_segm() if it suits the goal. If loader_t::move_segm is not defined then this function will be called automatically when moving segments or rebasing the entire program. Special parameter values (from = BADADDR, size = 0, to = delta) are used when the function is called from rebase_program(delta).

  @param from: (C++: ea_t) @param to: (C++: ea_t) @param size: (C++: asize_t)

`def get_first_fixup_ea()`

  get_first_fixup_ea() -> ea_t

`def get_fixup(fd: fixup_data_t, source: ea_t)`

  get_fixup(fd, source) -> bool Get fixup information.

  @param fd: (C++: fixup_data_t *) @param source: (C++: ea_t)

`def get_fixup_desc(source: ea_t, fd: fixup_data_t)`

  get_fixup_desc(source, fd) -> str Get FIXUP description comment.

  @param source: (C++: ea_t) @param fd: (C++: const fixup_data_t &) fixup_data_t const &

`def get_fixup_handler(type: fixup_type_t)`

  get_fixup_handler(type) -> fixup_handler_t const * Get handler of standard or custom fixup.

  @param type: (C++: fixup_type_t)

`def get_fixup_value(ea: ea_t, type: fixup_type_t)`

  get_fixup_value(ea, type) -> uval_t Get the operand value. This function get fixup bytes from data or an instruction at `ea` and convert them to the operand value (maybe partially). It is opposite in meaning to the `patch_fixup_value()`. For example, FIXUP_HI8 read a byte at `ea` and shifts it left by 8 bits, or AArch64's custom fixup BRANCH26 get low 26 bits of the insn at `ea` and shifts it left by 2 bits. This function is mainly used to get a relocation addend.

  @param ea: (C++: ea_t) address to get fixup bytes from, the size of the fixup bytes depends on the fixup type. @see: fixup_handler_t::size @param type: (C++: fixup_type_t) fixup type @retval operand: value

`def get_fixups(out: fixups_t *, ea: ea_t, size: asize_t)`

  get_fixups(out, ea, size) -> bool

  @param out: fixups_t * @param ea: ea_t @param size: asize_t

`def get_next_fixup_ea(ea: ea_t)`

  get_next_fixup_ea(ea) -> ea_t Find next address with fixup information

  @param ea: (C++: ea_t) current address @return: the next address with fixup information, or BADADDR

`def get_prev_fixup_ea(ea: ea_t)`

  get_prev_fixup_ea(ea) -> ea_t Find previous address with fixup information

  @param ea: (C++: ea_t) current address @return: the previous address with fixup information, or BADADDR

`def handle_fixups_in_macro(ri: refinfo_t, ea: ea_t, other: fixup_type_t, macro_reft_and_flags: uint32)`

  handle_fixups_in_macro(ri, ea, other, macro_reft_and_flags) -> bool Handle two fixups in a macro. We often combine two instruction that load parts of a value into one macro instruction. For example: ARM: ADRP X0, #var@PAGE ADD X0, X0, #var@PAGEOFF –> ADRL X0, var MIPS: lui $v0, %hi(var) addiu $v0, $v0, %lo(var) –> la $v0, var When applying the fixups that fall inside such a macro, we should convert them to one refinfo. This function does exactly that. It should be called from the apply() callback of a custom fixup.

  @param ri: (C++: refinfo_t *) @param ea: (C++: ea_t) @param other: (C++: fixup_type_t) @param macro_reft_and_flags: (C++: uint32) @return: success ('false' means that RI was not changed)

`def is_fixup_custom(type: fixup_type_t)`

  is_fixup_custom(type) -> bool Is fixup processed by processor module?

  @param type: (C++: fixup_type_t)

`def patch_fixup_value(ea: ea_t, fd: fixup_data_t)`

  patch_fixup_value(ea, fd) -> bool Patch the fixup bytes. This function updates data or an instruction at `ea` to the fixup bytes. For example, FIXUP_HI8 updates a byte at `ea` to the high byte of `fd->off`, or AArch64's custom fixup BRANCH26 updates low 26 bits of the insn at `ea` to the value of `fd->off` shifted right by 2.

  @param ea: (C++: ea_t) address where data are changed, the size of the changed data depends on the fixup type. @see: fixup_handler_t::size @param fd: (C++: const fixup_data_t &) fixup data @retval false: the fixup bytes do not fit (e.g. `fd->off` is greater than 0xFFFFFFC for BRANCH26). The database is changed even in this case.

`def set_fixup(source: ea_t, fd: fixup_data_t)`

  set_fixup(source, fd) Set fixup information. You should fill fixup_data_t and call this function and the kernel will remember information in the database.

  @param source: (C++: ea_t) the fixup source address, i.e. the address modified by the fixup @param fd: (C++: const fixup_data_t &) fixup data

## Classes

`class fixup_data_t (*args)`

  Proxy of C++ fixup_data_t class.

  init(self) -> fixup_data_t init(self, type_, flags_=0) -> fixup_data_t

  @param type_: fixup_type_t @param flags_: uint32

  ### Instance variables

  `var displacement : adiff_t`

    displacement (offset from the target)

  `var off : ea_t`

    target offset @note: The target is calculated as `get_base() + off`.

  `var sel : sel_t`

    selector of the target segment. BADSEL means an absolute (zero based) target. @see: FIXUPF_REL

  `var thisown`

    The membership flag

  ### Methods

  `def calc_size(self) ‑> int`

    calc_size(self) -> int calc_fixup_size()

  `def clr_extdef(self)`

    clr_extdef(self)

  `def clr_unused(self)`

    clr_unused(self)

  `def get(self, source: ea_t)`

    get(self, source) -> bool get_fixup()

    @param source: (C++: ea_t)

  `def get_base(self)`

    get_base(self) -> ea_t Get base of fixup. @note: The target is calculated as `get_base() + off`. @see: FIXUPF_REL

  `def get_desc(self, source: ea_t)`

    get_desc(self, source) -> char const * get_fixup_desc()

    @param source: (C++: ea_t)

  `def get_flags(self)`

    get_flags(self) -> uint32 Fixup flags Fixup flags.

  `def get_handler(self)`

    get_handler(self) -> fixup_handler_t const * get_fixup_handler()

  `def get_type(self)`

    get_type(self) -> fixup_type_t Fixup type Types of fixups.

  `def get_value(self, ea: ea_t)`

    get_value(self, ea) -> uval_t get_fixup_value()

    @param ea: (C++: ea_t)

  `def has_base(self) ‑> bool`

    has_base(self) -> bool Is fixup relative?

  `def is_custom(self) ‑> bool`

    is_custom(self) -> bool is_fixup_custom()

  `def is_extdef(self) ‑> bool`

    is_extdef(self) -> bool

  `def is_unused(self) ‑> bool`

    is_unused(self) -> bool

  `def patch_value(self, ea: ea_t)`

    patch_value(self, ea) -> bool patch_fixup_value()

    @param ea: (C++: ea_t)

  `def set(self, source: ea_t)`

    set(self, source) set_fixup()

    @param source: (C++: ea_t)

  `def set_base(self, new_base: ea_t)`

    set_base(self, new_base) Set base of fixup. The target should be set before a call of this function.

    @param new_base: (C++: ea_t)

  `def set_extdef(self)`

    set_extdef(self)

  `def set_sel(self, seg: segment_t const *)`

    set_sel(self, seg)

    @param seg: segment_t const *

  `def set_target_sel(self)`

    set_target_sel(self) Set selector of fixup to the target. The target should be set before a call of this function.

  `def set_type(self, type_: fixup_type_t)`

    set_type(self, type_)

    @param type_: fixup_type_t

  `def set_type_and_flags(self, type_: fixup_type_t, flags_: uint32 = 0)`

    set_type_and_flags(self, type_, flags_=0)

    @param type_: fixup_type_t @param flags_: uint32

  `def set_unused(self)`

    set_unused(self)

  `def was_created(self) ‑> bool`

    was_created(self) -> bool Is fixup artificial?

`class fixup_info_t`

  Proxy of C++ fixup_info_t class.

  init(self) -> fixup_info_t

  ### Instance variables

  `var ea : ea_t`

    ea

  `var fd : fixup_data_t`

    fd

  `var thisown`

    The membership flag