Module ida_search

They all are controlled by Search flags

Global Variables

SEARCH_BRK

SEARCH_BRK = 256

SEARCH_CASE

SEARCH_CASE = 4

SEARCH_DEF

SEARCH_DEF = 1024

SEARCH_DOWN

SEARCH_DOWN = 1

SEARCH_IDENT

SEARCH_IDENT = 128

SEARCH_NEXT

SEARCH_NEXT = 2

SEARCH_NOBRK

SEARCH_NOBRK = 16

SEARCH_NOSHOW

SEARCH_NOSHOW = 32

SEARCH_REGEX

SEARCH_REGEX = 8

SEARCH_UP

SEARCH_UP = 0

SEARCH_USE

SEARCH_USE = 512

SEARCH_USESEL

SEARCH_USESEL = 2048

Functions

find_code(ea: ea_t, sflag: int) ‑> ea_t

find_code(ea, sflag) -> ea_t Find next code address.

ea: (C++: ea_t)
sflag: (C++: int)

find_data(ea: ea_t, sflag: int) ‑> ea_t

find_data(ea, sflag) -> ea_t Find next data address.

ea: (C++: ea_t)
sflag: (C++: int)

find_defined(ea: ea_t, sflag: int) ‑> ea_t

find_defined(ea, sflag) -> ea_t Find next ea that is the start of an instruction or data.

ea: (C++: ea_t)
sflag: (C++: int)

find_error(ea: ea_t, sflag: int) ‑> int *

find_error(ea, sflag) -> ea_t Find next error or problem.

ea: (C++: ea_t)
sflag: (C++: int)

find_imm(ea: ea_t, sflag: int, search_value: uval_t) ‑> int *

find_imm(ea, sflag, search_value) -> ea_t Find next immediate operand with the given value.

ea: (C++: ea_t)
sflag: (C++: int)
search_value: (C++: uval_t)

find_not_func(ea: ea_t, sflag: int) ‑> ea_t

find_not_func(ea, sflag) -> ea_t Find next code address that does not belong to a function.

ea: (C++: ea_t)
sflag: (C++: int)

find_notype(ea: ea_t, sflag: int) ‑> int *

find_notype(ea, sflag) -> ea_t Find next operand without any type info.

ea: (C++: ea_t)
sflag: (C++: int)

find_reg_access(out: reg_access_t, start_ea: ea_t, end_ea: ea_t, regname: char const *, sflag: int) ‑> ea_t

find_reg_access(out, start_ea, end_ea, regname, sflag) -> ea_t Find access to a register.

out: (C++: struct reg_access_t *) pointer to the output buffer. must be non-null. upon success
           contains info about the found register. upon failed search for a
           read access out->range contains the info about the non-redefined
           parts of the register.
start_ea: (C++: ea_t) starting address
end_ea: (C++: ea_t) ending address. BADADDR means that the end limit is missing.
              otherwise, if the search direction is SEARCH_UP, END_EA must be
              lower than START_EA.
regname: (C++: const char *) the register to search for.
sflag: (C++: int) combination of Search flags bits.
note: This function does not care about the control flow and probes all
      instructions in the specified range, starting from START_EA. Only direct
      references to registers are detected. Function calls and system traps are
      ignored.
return: the found address. BADADDR if not found or error.

find_suspop(ea: ea_t, sflag: int) ‑> int *

find_suspop(ea, sflag) -> ea_t Find next suspicious operand.

ea: (C++: ea_t)
sflag: (C++: int)

find_text(start_ea: ea_t, y: int, x: int, ustr: char const *, sflag: int) ‑> ea_t

find_text(start_ea, y, x, ustr, sflag) -> ea_t See search()

start_ea: (C++: ea_t)
y: (C++: int)
x: (C++: int)
ustr: (C++: const char *) char const *
sflag: (C++: int)

find_unknown(ea: ea_t, sflag: int) ‑> ea_t

find_unknown(ea, sflag) -> ea_t Find next unexplored address.

ea: (C++: ea_t)
sflag: (C++: int)

search_down(sflag: int) ‑> bool

search_down(sflag) -> bool Is the SEARCH_DOWN bit set?

sflag: (C++: int)