Module index

Module ida_idp

IDA Plugin SDK API wrapper: idp

Global variables

var AS2_BRACE
Use braces for all expressions.
var AS2_BYTE1CHAR
One symbol per processor byte Meaningful only for wide byte processors
var AS2_COLONSUF
addresses may have ":xx" suffix this suffix must be ignored when extracting the address under the cursor
var AS2_IDEALDSCR
Description of struc/union is in the 'reverse' form (keyword before name) the same as in borland tasm ideal
var AS2_STRINV
Invert meaning of \inf{wide_high_byte_first} for text strings (For processors with bytes bigger than 8 bits)
var AS2_TERSESTR
'terse' structure initialization form NAME<fld,fld,...> is supported
var AS2_YWORD
a_yword field is present and valid
var ASB_BINF0
010101b
var ASB_BINF1
^B010101
var ASB_BINF2
%010101
var ASB_BINF3
0b1010101
var ASB_BINF4
b'1010101
var ASB_BINF5
b'1010101'
var ASD_DECF0
34
var ASD_DECF1
#34
var ASD_DECF2
ASD_DECF2 = 8192
var ASD_DECF3
.34
var ASH_HEXF0
34h
var ASH_HEXF1
h'34
var ASH_HEXF2
34
var ASH_HEXF3
0x34
var ASH_HEXF4
$34
var ASH_HEXF5
<^R > (radix)
var ASO_OCTF0
123o
var ASO_OCTF1
0123
var ASO_OCTF2
123
var ASO_OCTF3
@123
var ASO_OCTF4
o'123
var ASO_OCTF5
123q
var ASO_OCTF6
~123
var ASO_OCTF7
q'123
var AS_1TEXT
1 text per line, no bytes
var AS_2CHRE
double char constants are: "xy
var AS_ALIGN2
.align directive expects an exponent rather than a power of 2 (.align 5 means to align at 32byte boundary)
var AS_ASCIIC
ascii directive accepts C-like escape sequences (\n,\x01 and similar)
var AS_ASCIIZ
ascii directive inserts implicit zero byte at the end
var AS_BINFM
mask - binary number format
var AS_COLON
create colons after data names ?
var AS_DECFM
mask - decimal number format
var AS_HEXFM
mask - hex number format
var AS_LALIGN
Labels at "align" keyword are supported.
var AS_N2CHR
can't have 2 byte char consts
var AS_NCHRE
char constants are: 'x
var AS_NCMAS
no commas in ascii directives
var AS_NHIAS
no characters with high bit
var AS_NOCODECLN
don't create colons after code names
var AS_NOSPACE
No spaces in expressions.
var AS_NOXRF
Disable xrefs during the output file generation.
var AS_OCTFM
mask - octal number format
var AS_OFFST
offsets are 'offset xxx' ?
var AS_ONEDUP
One array definition per line.
var AS_RELSUP
Checkarg: 'and','or','xor' operations with addresses are possible.
var AS_UDATA
can use '?' in data directives
var AS_UNEQU
replace undefined data items with EQU (for ANTA's A80)
var AS_XTRNTYPE
Assembler understands type of extern symbols as ":type" suffix.
var CF_CALL
CALL instruction (should make a procedure here)
var CF_CHG1
The instruction modifies the first operand.
var CF_CHG2
The instruction modifies the second operand.
var CF_CHG3
The instruction modifies the third operand.
var CF_CHG4
The instruction modifies 4 operand.
var CF_CHG5
The instruction modifies 5 operand.
var CF_CHG6
The instruction modifies 6 operand.
var CF_CHG7
The instruction modifies the 7th operand.
var CF_CHG8
The instruction modifies the 8th operand.
var CF_HLL
Instruction may be present in a high level language function.
var CF_JUMP
The instruction passes execution using indirect jump or call (thus needs additional analysis)
var CF_SHFT
Bit-shift instruction (shl,shr...)
var CF_STOP
Instruction doesn't pass execution to the next instruction
var CF_USE1
The instruction uses value of the first operand.
var CF_USE2
The instruction uses value of the second operand.
var CF_USE3
The instruction uses value of the third operand.
var CF_USE4
The instruction uses value of the 4 operand.
var CF_USE5
The instruction uses value of the 5 operand.
var CF_USE6
The instruction uses value of the 6 operand.
var CF_USE7
The instruction uses value of the 7th operand.
var CF_USE8
The instruction uses value of the 8th operand.
var CUSTOM_INSN_ITYPE
Custom instruction codes defined by processor extension plugins must be greater than or equal to this
var HKCB_GLOBAL
is global event listener? if true, the listener will survive database closing and opening. it will stay in the memory until explicitly unhooked. otherwise the kernel will delete it as soon as the owner is unloaded. should be used only with PLUGIN_FIX plugins.
var IDPOPT_BADKEY
IDPOPT_BADKEY = 1
var IDPOPT_BADTYPE
IDPOPT_BADTYPE = 2
var IDPOPT_BADVALUE
IDPOPT_BADVALUE = 3
var IDPOPT_BIT
IDPOPT_BIT = 3
var IDPOPT_BIT_BOOL
IDPOPT_BIT_BOOL = 50331648
var IDPOPT_BIT_UCHAR
IDPOPT_BIT_UCHAR = 16777216
var IDPOPT_BIT_UINT
IDPOPT_BIT_UINT = 0
var IDPOPT_BIT_USHORT
IDPOPT_BIT_USHORT = 33554432
var IDPOPT_CST
IDPOPT_CST = 6
var IDPOPT_CST_PARAMS
IDPOPT_CST_PARAMS = 16777216
var IDPOPT_FLT
IDPOPT_FLT = 4
var IDPOPT_I64
IDPOPT_I64 = 5
var IDPOPT_I64_RANGES
IDPOPT_I64_RANGES = 16777216
var IDPOPT_I64_UNS
IDPOPT_I64_UNS = 33554432
var IDPOPT_MBROFF
IDPOPT_MBROFF = 262144
var IDPOPT_NUM
IDPOPT_NUM = 2
var IDPOPT_NUM_CHAR
IDPOPT_NUM_CHAR = 16777216
var IDPOPT_NUM_INT
IDPOPT_NUM_INT = 0
var IDPOPT_NUM_RANGE
IDPOPT_NUM_RANGE = 67108864
var IDPOPT_NUM_SHORT
IDPOPT_NUM_SHORT = 33554432
var IDPOPT_NUM_UNS
IDPOPT_NUM_UNS = 134217728
var IDPOPT_OK
IDPOPT_OK = 0
var IDPOPT_PRI_DEFAULT
IDPOPT_PRI_DEFAULT = 1
var IDPOPT_PRI_HIGH
IDPOPT_PRI_HIGH = 2
var IDPOPT_STR
IDPOPT_STR = 1
var IDPOPT_STR_LONG
IDPOPT_STR_LONG = 33554432
var IDPOPT_STR_QSTRING
IDPOPT_STR_QSTRING = 16777216
var IDP_INTERFACE_VERSION
The interface version number.see also 'IDA_SDK_VERSION' from 'pro.h'
var NO_ACCESS
NO_ACCESS = 0
var OP_FP_BASED
operand is FP based
var OP_SP_ADD
operand value is added to the pointer
var OP_SP_BASED
operand is SP based
var OP_SP_SUB
operand value is subtracted from the pointer
var PLFM_386
Intel 80x86.
var PLFM_6502
6502
var PLFM_65C816
65802/65816
var PLFM_6800
Motorola 68xx.
var PLFM_68K
Motorola 680x0.
var PLFM_80196
Intel 80196.
var PLFM_8051
8051
var PLFM_AD2106X
Analog Devices ADSP 2106X.
var PLFM_AD218X
Analog Devices ADSP 218X.
var PLFM_ALPHA
DEC Alpha.
var PLFM_ARC
Argonaut RISC Core.
var PLFM_ARM
Advanced RISC Machines.
var PLFM_AVR
Atmel 8-bit RISC processor(s)
var PLFM_C166
Siemens C166 family.
var PLFM_C39
Rockwell C39.
var PLFM_CR16
NSC CR16.
var PLFM_DALVIK
Android Dalvik Virtual Machine.
var PLFM_DSP56K
Motorola DSP5600x.
var PLFM_DSP96K
Motorola DSP96000.
var PLFM_EBC
EFI Bytecode.
var PLFM_F2MC
Fujistu F2MC-16.
var PLFM_FR
Fujitsu FR Family.
var PLFM_H8
Hitachi H8/300, H8/2000.
var PLFM_H8500
Hitachi H8/500.
var PLFM_HPPA
Hewlett-Packard PA-RISC.
var PLFM_I860
Intel 860.
var PLFM_I960
Intel 960.
var PLFM_IA64
Intel Itanium IA64.
var PLFM_JAVA
Java.
var PLFM_KR1878
Angstrem KR1878.
var PLFM_M16C
Renesas M16C.
var PLFM_M32R
Mitsubishi 32bit RISC.
var PLFM_M740
Mitsubishi 8bit.
var PLFM_M7700
Mitsubishi 16bit.
var PLFM_M7900
Mitsubishi 7900.
var PLFM_MC6812
Motorola 68HC12.
var PLFM_MC6816
Motorola 68HC16.
var PLFM_MIPS
MIPS.
var PLFM_MN102L00
Panasonic MN10200.
var PLFM_MSP430
Texas Instruments MSP430.
var PLFM_NEC_78K0
NEC 78K0.
var PLFM_NEC_78K0S
NEC 78K0S.
var PLFM_NEC_V850X
NEC V850 and V850ES/E1/E2.
var PLFM_NET
Microsoft Visual Studio.Net.
var PLFM_OAKDSP
Atmel OAK DSP.
var PLFM_PDP
PDP11.
var PLFM_PIC
Microchip's PIC.
var PLFM_PIC16
Microchip's 16-bit PIC.
var PLFM_PPC
PowerPC.
var PLFM_RISCV
RISC-V.
var PLFM_RL78
Renesas RL78.
var PLFM_S390
IBM's S390.
var PLFM_SCR_ADPT
Processor module adapter for processor modules written in scripting languages.
var PLFM_SH
Renesas (formerly Hitachi) SuperH.
var PLFM_SPARC
SPARC.
var PLFM_SPC700
Sony SPC700.
var PLFM_SPU
Cell Broadband Engine Synergistic Processor Unit.
var PLFM_ST20
SGS-Thomson ST20.
var PLFM_ST7
SGS-Thomson ST7.
var PLFM_ST9
ST9+.
var PLFM_TLCS900
Toshiba TLCS-900.
var PLFM_TMS
Texas Instruments TMS320C5x.
var PLFM_TMS320C1X
Texas Instruments TMS320C1x.
var PLFM_TMS320C28
Texas Instruments TMS320C28x.
var PLFM_TMS320C3
Texas Instruments TMS320C3.
var PLFM_TMS320C54
Texas Instruments TMS320C54xx.
var PLFM_TMS320C55
Texas Instruments TMS320C55xx.
var PLFM_TMSC6
Texas Instruments TMS320C6x.
var PLFM_TRICORE
Tasking Tricore.
var PLFM_TRIMEDIA
Trimedia.
var PLFM_UNSP
SunPlus unSP.
var PLFM_XTENSA
Tensilica Xtensa.
var PLFM_Z8
Z8.
var PLFM_Z80
8085, Z80
var PR2_CODE16_BIT
low bit of code addresses has special meaning e.g. ARM Thumb, MIPS16
var PR2_IDP_OPTS
the module has processor-specific configuration options
var PR2_MACRO
processor supports macro instructions
var PR2_MAPPINGS
the processor module uses memory mapping
var PR2_REALCVT
the module has a custom 'ev_realcvt' implementation (otherwise IEEE-754 format is assumed)
var PR2_REL_BITS
(Lumina) calcrel info has bits granularity, not bytes - construction flag only
var PR2_USE_CALCREL
(Lumina) the module supports calcrel info
var PRN_BIN
binary
var PRN_DEC
decimal
var PRN_HEX
hex
var PRN_OCT
octal
var PR_ADJSEGS
IDA may adjust segments' starting/ending addresses.
var PR_ALIGN
All data items should be aligned properly.
var PR_ALIGN_INSN
allow ida to create alignment instructions arbitrarily. Since these instructions might lead to other wrong instructions and spoil the listing, IDA does not create them by default anymore
var PR_ASSEMBLE
Module has a built-in assembler and will react to ev_assemble.
var PR_BINMEM
the processor module provides correct segmentation for binary files (i.e. it creates additional segments) The kernel will not ask the user to specify the RAM/ROM sizes
var PR_CHK_XREF
don't allow near xrefs between segments with different bases
var PR_CNDINSNS
has conditional instructions
var PR_DEFNUM
mask - default number representation
var PR_DEFSEG32
segments are 32-bit by default
var PR_DEFSEG64
segments are 64-bit by default
var PR_DELAYED
has delayed jumps and calls if this flag is set,
\ph{is_basic_block_end}
, \ph{has_delay_slot} should be implemented
var PR_NOCHANGE
The user can't change segments and code/data attributes (display only)
var PR_NO_SEGMOVE
the processor module doesn't support 'move_segm()' (i.e. the user can't move segments)
var PR_OUTER
has outer operands (currently only mc68k)
var PR_PURGING
there are calling conventions which may purge bytes from the stack
var PR_RNAMESOK
allow user register names for location names
var PR_SCALE_STKVARS
use \ph{get_stkvar_scale} callback
var PR_SEGS
has segment registers?
var PR_SEGTRANS
the processor module supports the segment translation feature (meaning it calculates the code addresses using the 'map_code_ea()' function)
var PR_SGROTHER
the segment registers don't contain the segment selectors.
var PR_STACK_UP
the stack grows up
var PR_TYPEINFO
the processor module supports type information callbacks ALL OF THEM SHOULD BE IMPLEMENTED!
var PR_USE32
supports 32-bit addressing?
var PR_USE64
supports 64-bit addressing?
var PR_USE_ARG_TYPES
use \ph{use_arg_types} callback
var PR_USE_TBYTE
'BTMT_SPECFLT' means _TBYTE type
var PR_WORD_INS
instruction codes are grouped 2bytes in binary line prefix
var READ_ACCESS
READ_ACCESS = 2
var REAL_ERROR_BADDATA
REAL_ERROR_BADDATA = -3
var REAL_ERROR_FORMAT
REAL_ERROR_FORMAT = -1
var REAL_ERROR_RANGE
REAL_ERROR_RANGE = -2
var REG_SPOIL
processor_t::use_regarg_type uses this bit in the return value to indicate that the register value has been spoiled
var RW_ACCESS
RW_ACCESS = 3
var SETPROC_IDB
SETPROC_IDB = 0
var SETPROC_LOADER
SETPROC_LOADER = 1
var SETPROC_LOADER_NON_FATAL
SETPROC_LOADER_NON_FATAL = 2
var SETPROC_USER
SETPROC_USER = 3
var WRITE_ACCESS
WRITE_ACCESS = 1
var adding_segm
adding_segm = 94
var allsegs_moved
allsegs_moved = 62
var auto_empty
auto_empty = 3
var auto_empty_finally
auto_empty_finally = 4
var bookmark_changed
bookmark_changed = 92
var byte_patched
byte_patched = 84
var callee_addr_changed
callee_addr_changed = 91
var changing_cmt
changing_cmt = 85
var changing_enum_bf
changing_enum_bf = 24
var changing_enum_cmt
changing_enum_cmt = 26
var changing_op_ti
changing_op_ti = 15
var changing_op_type
changing_op_type = 17
var changing_range_cmt
changing_range_cmt = 87
var changing_segm_class
changing_segm_class = 58
var changing_segm_end
changing_segm_end = 54
var changing_segm_name
changing_segm_name = 56
var changing_segm_start
changing_segm_start = 52
var changing_struc_align
changing_struc_align = 34
var changing_struc_cmt
changing_struc_cmt = 47
var changing_struc_member
changing_struc_member = 45
var changing_ti
changing_ti = 13
var closebase
closebase = 0
var cmt_changed
cmt_changed = 86
var compiler_changed
compiler_changed = 12
var deleting_enum
deleting_enum = 20
var deleting_enum_member
deleting_enum_member = 29
var deleting_func
deleting_func = 67
var deleting_func_tail
deleting_func_tail = 71
var deleting_segm
deleting_segm = 50
var deleting_struc
deleting_struc = 32
var deleting_struc_member
deleting_struc_member = 41
var deleting_tryblks
deleting_tryblks = 78
var destroyed_items
destroyed_items = 82
var determined_main
determined_main = 5
dirtree_link = 98
var dirtree_mkdir
dirtree_mkdir = 96
var dirtree_move
dirtree_move = 99
var dirtree_rank
dirtree_rank = 100
var dirtree_rmdir
dirtree_rmdir = 97
var dirtree_rminode
dirtree_rminode = 101
var dirtree_segm_moved
dirtree_segm_moved = 102
var enum_bf_changed
enum_bf_changed = 25
var enum_cmt_changed
enum_cmt_changed = 27
var enum_created
enum_created = 19
var enum_deleted
enum_deleted = 21
var enum_member_created
enum_member_created = 28
var enum_member_deleted
enum_member_deleted = 30
var enum_renamed
enum_renamed = 23
var expanding_struc
expanding_struc = 38
var extlang_changed
extlang_changed = 7
var extra_cmt_changed
extra_cmt_changed = 89
var flow_chart_created
flow_chart_created = 11
var frame_deleted
frame_deleted = 68
var func_added
func_added = 63
var func_deleted
func_deleted = 95
var func_noret_changed
func_noret_changed = 74
var func_tail_appended
func_tail_appended = 70
var func_tail_deleted
func_tail_deleted = 72
var func_updated
func_updated = 64
var idasgn_loaded
idasgn_loaded = 8
var item_color_changed
item_color_changed = 90
var kernel_config_loaded
kernel_config_loaded = 9
var loader_finished
loader_finished = 10
var local_types_changed
local_types_changed = 6
var make_code
make_code = 80
var make_data
make_data = 81
var op_ti_changed
op_ti_changed = 16
var op_type_changed
op_type_changed = 18
var range_cmt_changed
range_cmt_changed = 88
var renamed
renamed = 83
var renaming_enum
renaming_enum = 22
var renaming_struc
renaming_struc = 36
var renaming_struc_member
renaming_struc_member = 43
var savebase
savebase = 1
var segm_added
segm_added = 49
var segm_attrs_updated
segm_attrs_updated = 60
var segm_class_changed
segm_class_changed = 59
var segm_deleted
segm_deleted = 51
var segm_end_changed
segm_end_changed = 55
var segm_moved
segm_moved = 61
var segm_name_changed
segm_name_changed = 57
var segm_start_changed
segm_start_changed = 53
var set_func_end
set_func_end = 66
var set_func_start
set_func_start = 65
var sgr_changed
sgr_changed = 79
var sgr_deleted
sgr_deleted = 93
var stkpnts_changed
stkpnts_changed = 75
var struc_align_changed
struc_align_changed = 35
var struc_cmt_changed
struc_cmt_changed = 48
var struc_created
struc_created = 31
var struc_deleted
struc_deleted = 33
var struc_expanded
struc_expanded = 39
var struc_member_changed
struc_member_changed = 46
var struc_member_created
struc_member_created = 40
var struc_member_deleted
struc_member_deleted = 42
var struc_member_renamed
struc_member_renamed = 44
var struc_renamed
struc_renamed = 37
var tail_owner_changed
tail_owner_changed = 73
var thunk_func_created
thunk_func_created = 69
var ti_changed
ti_changed = 14
var tryblks_updated
tryblks_updated = 77
var updating_tryblks
updating_tryblks = 76
var upgraded
upgraded = 2

Functions

def AssembleLine(*args) ‑> PyObject *
AssembleLine(ea, cs, ip, use32, nonnul_line) -> PyObject *
Assemble an instruction to a string (display a warning if an error is found)
ea: linear address of instruction
cs: cs of instruction
ip: ip of instruction
use32: is 32bit segment
line: line to assemble
return:
  • None on failure
  • or a string containing the assembled instruction
def assemble(*args) ‑> bool
assemble(ea, cs, ip, use32, line) -> bool
Assemble an instruction into the database (display a warning if an error is found)
ea: linear address of instruction
cs: cs of instruction
ip: ip of instruction
use32: is 32bit segment?
line: line to assemble
return: Boolean. True on success.
def cfg_get_cc_header_path(*args) ‑> char const *
cfg_get_cc_header_path(compid) -> char const *
compid: comp_t
def cfg_get_cc_parm(*args) ‑> char const *
cfg_get_cc_parm(compid, name) -> char const *
compid: comp_t name: char const *
def cfg_get_cc_predefined_macros(*args) ‑> char const *
cfg_get_cc_predefined_macros(compid) -> char const *
compid: comp_t
def clr_module_data(*args) ‑> void *
Unregister pointer to database specific module data.
clr_module_data(data_id) -> void *
data_id: an data_id that was assigned by set_module_data()
(C++: int)
return: previously registered pointer for the current database. it
can be deallocated now. Multiple calls to this function with the same id are forbidden.
def delay_slot_insn(*args) ‑> bool
delay_slot_insn(ea, bexec, fexec) -> bool
ea: ea_t * bexec: bool * fexec: bool *
def gen_idb_event(*args) ‑> void
the kernel will use this function to generate idb_events
gen_idb_event(code)
code (C++: idb_event::event_code_t)
def get_ash(*args) ‑> asm_t *
get_ash() -> asm_t
def get_idb_notifier_addr(*args) ‑> PyObject *
get_idb_notifier_addr(arg1) -> PyObject *
arg1: PyObject *
def get_idb_notifier_ud_addr(*args) ‑> PyObject *
get_idb_notifier_ud_addr(hooks) -> PyObject *
hooks: IDB_Hooks *
def get_idp_name(*args) ‑> size_t
Get name of the current processor module. The name is derived from the file name. For example, for IBM PC the module is named "pc.w32" (windows version), then the module name is "PC" (uppercase). If no processor module is loaded, this function will return NULL
def get_idp_notifier_addr(*args) ‑> PyObject *
get_idp_notifier_addr(arg1) -> PyObject *
arg1: PyObject *
def get_idp_notifier_ud_addr(*args) ‑> PyObject *
get_idp_notifier_ud_addr(hooks) -> PyObject *
hooks: IDP_Hooks *
def get_module_data(*args) ‑> void *
Get pointer to the database specific module data.
get_module_data(data_id) -> void *
data_id: data id that was initialized by set_module_data()
(C++: int)
return: previously registered pointer for the current database
def get_ph(*args) ‑> processor_t *
get_ph() -> processor_t *
def get_reg_info(*args) ‑> char const *
get_reg_info(regname, bitrange) -> char const *
regname: char const * bitrange: bitrange_t *
def get_reg_name(*args) ‑> qstring *
Get text representation of a register. For most processors this function will just return \ph{reg_names} [reg]. If the processor module has implemented processor_t::get_reg_name, it will be used instead
get_reg_name(reg, width, reghi=-1) -> str
reg: internal register number as defined in the processor
module (C++: int)
width: register width in bytes (C++: size_t)
reghi: if specified, then this function will return the
register pair (C++: int)
return: length of register name in bytes or -1 if failure
def has_cf_chg(*args) ‑> bool
Does an instruction with the specified feature modify the i-th operand?
has_cf_chg(feature, opnum) -> bool
feature (C++: uint32)
opnum (C++: uint)
def has_cf_use(*args) ‑> bool
Does an instruction with the specified feature use a value of the i-th operand?
has_cf_use(feature, opnum) -> bool
feature (C++: uint32)
opnum (C++: uint)
def has_insn_feature(*args) ‑> bool
Does the specified instruction have the specified feature?
has_insn_feature(icode, bit) -> bool
icode (C++: int)
bit (C++: uint32)
def is_align_insn(*args) ‑> int
If the instruction at 'ea' looks like an alignment instruction, return its length in bytes. Otherwise return 0.
is_align_insn(ea) -> int
ea (C++: ea_t)
def is_basic_block_end(*args) ‑> bool
Is the instruction the end of a basic block?
is_basic_block_end(insn, call_insn_stops_block) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
call_insn_stops_block (C++: bool)
def is_call_insn(*args) ‑> bool
Is the instruction a "call"?
is_call_insn(insn) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
def is_indirect_jump_insn(*args) ‑> bool
Is the instruction an indirect jump?
is_indirect_jump_insn(insn) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
def is_ret_insn(*args) ‑> bool
Is the instruction a "return"?
is_ret_insn(insn, strict=True) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
strict (C++: bool)
def parse_reg_name(*args) ‑> bool
Get register info by name.
parse_reg_name(ri, regname) -> bool
ri: result (C++: reg_info_t *)
regname: name of register (C++: const char *)
return: success
def ph_calcrel(*args) ‑> bytevec_t *, size_t *
ph_calcrel(ea)
ea: ea_t
def ph_find_op_value(*args) ‑> uint32 *
ph_find_op_value(insn, op) -> ssize_t
insn: an ida_ua.insn_t, or an address (C++: const insn_t &) op: int
def ph_find_reg_value(*args) ‑> uint32 *
ph_find_reg_value(insn, reg) -> ssize_t
insn: an ida_ua.insn_t, or an address (C++: const insn_t &) reg: int
def ph_get_cnbits(*args) ‑> size_t
ph_get_cnbits() -> size_t
Returns the 'ph.cnbits'
def ph_get_dnbits(*args) ‑> size_t
ph_get_dnbits() -> size_t
Returns the 'ph.dnbits'
def ph_get_flag(*args) ‑> size_t
ph_get_flag() -> size_t
Returns the 'ph.flag'
def ph_get_icode_return(*args) ‑> size_t
ph_get_icode_return() -> size_t
Returns the 'ph.icode_return'
def ph_get_id(*args) ‑> size_t
ph_get_id() -> size_t
Returns the 'ph.id' field
def ph_get_instruc(*args) ‑> PyObject *
ph_get_instruc() -> PyObject *
Returns a list of tuples (instruction_name, instruction_feature) containing the instructions list as defined in he processor module
def ph_get_instruc_end(*args) ‑> size_t
ph_get_instruc_end() -> size_t
Returns the 'ph.instruc_end'
def ph_get_instruc_start(*args) ‑> size_t
ph_get_instruc_start() -> size_t
Returns the 'ph.instruc_start'
def ph_get_operand_info(*args) ‑> PyObject *
ph_get_operand_info(ea, n) -> PyObject *
Returns the operand information given an ea and operand number.
ea: address
n: operand number
return: Returns an idd_opinfo_t as a tuple: (modified, ea, reg_ival, regidx, value_size).
Please refer to idd_opinfo_t structure in the SDK.
def ph_get_reg_accesses(*args) ‑> ssize_t
ph_get_reg_accesses(accvec, insn, flags) -> ssize_t
accvec: reg_accesses_t * insn: an ida_ua.insn_t, or an address (C++: const insn_t &) flags: int
def ph_get_reg_code_sreg(*args) ‑> size_t
ph_get_reg_code_sreg() -> size_t
Returns the 'ph.reg_code_sreg'
def ph_get_reg_data_sreg(*args) ‑> size_t
ph_get_reg_data_sreg() -> size_t
Returns the 'ph.reg_data_sreg'
def ph_get_reg_first_sreg(*args) ‑> size_t
ph_get_reg_first_sreg() -> size_t
Returns the 'ph.reg_first_sreg'
def ph_get_reg_last_sreg(*args) ‑> size_t
ph_get_reg_last_sreg() -> size_t
Returns the 'ph.reg_last_sreg'
def ph_get_regnames(*args) ‑> PyObject *
ph_get_regnames() -> PyObject *
Returns the list of register names as defined in the processor module
def ph_get_segreg_size(*args) ‑> size_t
ph_get_segreg_size() -> size_t
Returns the 'ph.segreg_size'
def ph_get_tbyte_size(*args) ‑> size_t
ph_get_tbyte_size() -> size_t
Returns the 'ph.tbyte_size' field as defined in he processor module
def ph_get_version(*args) ‑> size_t
ph_get_version() -> size_t
Returns the 'ph.version'
def process_config_directive(*args) ‑> void
process_config_directive(directive, priority=2)
directive: char const * priority: int
def register_cfgopts(*args) ‑> bool
register_cfgopts(opts, nopts, cb=None, obj=None) -> bool
opts: cfgopt_t const [] nopts: size_t cb: config_changed_cb_t * obj: void *
def set_module_data(*args) ‑> void *
Starting from IDA v7.5 all modules should use the following 3 functions to handle idb specific static data because now the kernel supports opening and working with multiple idbs files simultaneously. See the source code of the processor modules in the SDK for the usage examples. Register pointer to database specific module data.
set_module_data(data_id, data_ptr) -> void *
data_id: initially the pointed-to value must be 0, the kernel
will fill it with a unique id. once assigned, the data_id does not change. (C++: int *)
data_ptr: pointer to the data to register (C++: void *)
return: data_ptr. The registered pointer can later be retrieved using
get_module_data()
def set_processor_type(*args) ‑> bool
Set target processor type. Once a processor module is loaded, it cannot be replaced until we close the idb.
set_processor_type(procname, level) -> bool
procname: name of processor type (one of names present in
\ph{psnames}
) (C++: const char *)
level: SETPROC_ (C++: setproc_level_t)
return: success
def set_target_assembler(*args) ‑> bool
Set target assembler.
set_target_assembler(asmnum) -> bool
asmnum: number of assembler in the current processor module
(C++: int)
return: success
def sizeof_ldbl(*args) ‑> size_t
sizeof_ldbl() -> size_t
def str2reg(*args) ‑> int
Get any reg number (-1 on error)
str2reg(p) -> int
p (C++: const char *)

Classes

class IDB_Hooks (*args)
Proxy of C++ IDB_Hooks class.
__init__(self, _flags=0) -> IDB_Hooks
_flags: uint32

Subclasses

  • ida_idp._notify_when_dispatcher_t._IDB_Hooks
  • ida_idp._processor_t_Trampoline_IDB_Hooks

Methods

def adding_segm(self, *args) ‑> void
A segment is being created.
adding_segm(self, s)
s (C++: segment_t *)
def allsegs_moved(self, *args) ‑> void
Program rebasing is complete. This event is generated after series of segm_moved events
allsegs_moved(self, info)
info (C++: segm_move_infos_t *)
def auto_empty(self, *args) ‑> void
Info: all analysis queues are empty. This callback is called once when the initial analysis is finished. If the queue is not empty upon the return from this callback, it will be called later again.
def auto_empty_finally(self, *args) ‑> void
Info: all analysis queues are empty definitively. This callback is called only once.
def bookmark_changed(self, *args) ‑> void
Boomarked position changed.
bookmark_changed(self, index, pos, desc, operation)
index (C++: uint32)
pos (C++: const lochist_entry_t *)
desc (C++: const char *)
operation: 0-added, 1-updated, 2-deleted if desc==NULL, then
the bookmark was deleted. (C++: int)
def byte_patched(self, *args) ‑> void
A byte has been patched.
byte_patched(self, ea, old_value)
ea (C++: ea_t)
old_value (C++: uint32)
def callee_addr_changed(self, *args) ‑> void
Callee address has been updated by the user.
callee_addr_changed(self, ea, callee)
ea (C++: ea_t)
callee (C++: ea_t)
def changing_cmt(self, *args) ‑> void
An item comment is to be changed.
changing_cmt(self, ea, repeatable_cmt, newcmt)
ea (C++: ea_t)
repeatable_cmt (C++: bool)
newcmt (C++: const char *)
def changing_enum_bf(self, *args) ‑> void
An enum type 'bitfield' attribute is to be changed.
changing_enum_bf(self, id, new_bf)
id (C++: enum_t)
new_bf (C++: bool)
def changing_enum_cmt(self, *args) ‑> void
An enum or member type comment is to be changed.
changing_enum_cmt(self, id, repeatable, newcmt)
id (C++: tid_t)
repeatable (C++: bool)
newcmt (C++: const char *)
def changing_op_ti(self, *args) ‑> void
An operand typestring (c/c++ prototype) is to be changed.
changing_op_ti(self, ea, n, new_type, new_fnames)
ea (C++: ea_t)
n (C++: int)
new_type (C++: const type_t *)
new_fnames (C++: const p_list *)
def changing_op_type(self, *args) ‑> void
An operand type (offset, hex, etc...) is to be changed.
changing_op_type(self, ea, n, opinfo)
ea (C++: ea_t)
n: eventually or'ed with OPND_OUTER or OPND_ALL (C++: int)
opinfo: additional operand info (C++: const opinfo_t *)
def changing_range_cmt(self, *args) ‑> void
Range comment is to be changed.
changing_range_cmt(self, kind, a, cmt, repeatable)
kind (C++: range_kind_t)
a (C++: const range_t *)
cmt (C++: const char *)
repeatable (C++: bool)
def changing_segm_class(self, *args) ‑> void
Segment class is being changed.
changing_segm_class(self, s)
s (C++: segment_t *)
def changing_segm_end(self, *args) ‑> void
Segment end address is to be changed.
changing_segm_end(self, s, new_end, segmod_flags)
s (C++: segment_t *)
new_end (C++: ea_t)
segmod_flags (C++: int)
def changing_segm_name(self, *args) ‑> void
Segment name is being changed.
changing_segm_name(self, s, oldname)
s (C++: segment_t *)
oldname (C++: const char *)
def changing_segm_start(self, *args) ‑> void
Segment start address is to be changed.
changing_segm_start(self, s, new_start, segmod_flags)
s (C++: segment_t *)
new_start (C++: ea_t)
segmod_flags (C++: int)
def changing_struc_align(self, *args) ‑> void
A structure type is being changed (the struct alignment).
changing_struc_align(self, sptr)
sptr (C++: struc_t *)
def changing_struc_cmt(self, *args) ‑> void
A structure type comment is to be changed.
changing_struc_cmt(self, struc_id, repeatable, newcmt)
struc_id (C++: tid_t)
repeatable (C++: bool)
newcmt (C++: const char *)
def changing_struc_member(self, *args) ‑> void
A structure member is to be changed.
changing_struc_member(self, sptr, mptr, flag, ti, nbytes)
sptr (C++: struc_t *)
mptr (C++: member_t *)
flag (C++: flags_t)
ti (C++: const opinfo_t *)
nbytes (C++: asize_t)
def changing_ti(self, *args) ‑> void
An item typestring (c/c++ prototype) is to be changed.
changing_ti(self, ea, new_type, new_fnames)
ea (C++: ea_t)
new_type (C++: const type_t *)
new_fnames (C++: const p_list *)
def closebase(self, *args) ‑> void
The database will be closed now.
def cmt_changed(self, *args) ‑> void
An item comment has been changed.
cmt_changed(self, ea, repeatable_cmt)
ea (C++: ea_t)
repeatable_cmt (C++: bool)
def compiler_changed(self, *args) ‑> void
The kernel has changed the compiler information. (\inf{cc} structure; 'get_abi_name' )
compiler_changed(self, adjust_inf_fields)
adjust_inf_fields: may change inf fields? (C++: bool)
def deleting_enum(self, *args) ‑> void
An enum type is to be deleted.
deleting_enum(self, id)
id (C++: enum_t)
def deleting_enum_member(self, *args) ‑> void
An enum member is to be deleted.
deleting_enum_member(self, id, cid)
id (C++: enum_t)
cid (C++: const_t)
def deleting_func(self, *args) ‑> void
The kernel is about to delete a function.
deleting_func(self, pfn)
pfn (C++: func_t *)
def deleting_func_tail(self, *args) ‑> void
A function tail chunk is to be removed.
deleting_func_tail(self, pfn, tail)
pfn (C++: func_t *)
tail (C++: const range_t *)
def deleting_segm(self, *args) ‑> void
A segment is to be deleted.
deleting_segm(self, start_ea)
start_ea (C++: ea_t)
def deleting_struc(self, *args) ‑> void
A structure type is to be deleted.
deleting_struc(self, sptr)
sptr (C++: struc_t *)
def deleting_struc_member(self, *args) ‑> void
A structure member is to be deleted.
deleting_struc_member(self, sptr, mptr)
sptr (C++: struc_t *)
mptr (C++: member_t *)
def deleting_tryblks(self, *args) ‑> void
About to delete tryblk information in given range
deleting_tryblks(self, range)
range (C++: const range_t *)
def destroyed_items(self, *args) ‑> void
Instructions/data have been destroyed in [ea1,ea2).
destroyed_items(self, ea1, ea2, will_disable_range)
ea1 (C++: ea_t)
ea2 (C++: ea_t)
will_disable_range (C++: bool)
def determined_main(self, *args) ‑> void
The main() function has been determined.
determined_main(self, main)
main: address of the main() function (C++: ea_t)
Dirtree: an item has been linked/unlinked.
dirtree_link(self, dt, path, link)
dt (C++: dirtree_t *)
path (C++: const char *)
link (C++: bool)
def dirtree_mkdir(self, *args) ‑> void
Dirtree: a directory has been created.
dirtree_mkdir(self, dt, path)
dt (C++: dirtree_t *)
path (C++: const char *)
def dirtree_move(self, *args) ‑> void
Dirtree: a directory or item has been moved.
dirtree_move(self, dt, _from, to)
dt (C++: dirtree_t *)
_from (C++: const char *)
to (C++: const char *)
def dirtree_rank(self, *args) ‑> void
Dirtree: a directory or item rank has been changed.
dirtree_rank(self, dt, path, rank)
dt (C++: dirtree_t *)
path (C++: const char *)
rank (C++: size_t)
def dirtree_rmdir(self, *args) ‑> void
Dirtree: a directory has been deleted.
dirtree_rmdir(self, dt, path)
dt (C++: dirtree_t *)
path (C++: const char *)
def dirtree_rminode(self, *args) ‑> void
Dirtree: an inode became unavailable.
dirtree_rminode(self, dt, inode)
dt (C++: dirtree_t *)
inode (C++: inode_t)
def dirtree_segm_moved(self, *args) ‑> void
Dirtree: inodes were changed due to a segment movement or a program rebasing
dirtree_segm_moved(self, dt)
dt (C++: dirtree_t *)
def enum_bf_changed(self, *args) ‑> void
An enum type 'bitfield' attribute has been changed.
enum_bf_changed(self, id)
id (C++: enum_t)
def enum_cmt_changed(self, *args) ‑> void
An enum or member type comment has been changed.
enum_cmt_changed(self, id, repeatable)
id (C++: tid_t)
repeatable (C++: bool)
def enum_created(self, *args) ‑> void
An enum type has been created.
enum_created(self, id)
id (C++: enum_t)
def enum_deleted(self, *args) ‑> void
An enum type has been deleted.
enum_deleted(self, id)
id (C++: enum_t)
def enum_member_created(self, *args) ‑> void
An enum member has been created.
enum_member_created(self, id, cid)
id (C++: enum_t)
cid (C++: const_t)
def enum_member_deleted(self, *args) ‑> void
An enum member has been deleted.
enum_member_deleted(self, id, cid)
id (C++: enum_t)
cid (C++: const_t)
def enum_renamed(self, *args) ‑> void
An enum or member has been renamed.
enum_renamed(self, id)
id (C++: tid_t)
def expanding_struc(self, *args) ‑> void
A structure type is to be expanded/shrunk.
expanding_struc(self, sptr, offset, delta)
sptr (C++: struc_t *)
offset (C++: ea_t)
delta (C++: adiff_t)
def extlang_changed(self, *args) ‑> void
The list of extlangs or the default extlang was changed.
extlang_changed(self, kind, el, idx)
kind: 0: extlang installed 1: extlang removed 2: default
extlang changed (C++: int)
el: pointer to the extlang affected (C++: extlang_t *)
idx: extlang index (C++: int)
def extra_cmt_changed(self, *args) ‑> void
An extra comment has been changed.
extra_cmt_changed(self, ea, line_idx, cmt)
ea (C++: ea_t)
line_idx (C++: int)
cmt (C++: const char *)
def flow_chart_created(self, *args) ‑> void
Gui has retrieved a function flow chart. Plugins may modify the flow chart in this callback.
flow_chart_created(self, fc)
fc (C++: qflow_chart_t *)
def frame_deleted(self, *args) ‑> void
The kernel has deleted a function frame.
frame_deleted(self, pfn)
pfn (C++: func_t *)
def func_added(self, *args) ‑> void
The kernel has added a function.
func_added(self, pfn)
pfn (C++: func_t *)
def func_deleted(self, *args) ‑> void
A function has been deleted.
func_deleted(self, func_ea)
func_ea (C++: ea_t)
def func_noret_changed(self, *args) ‑> void
'FUNC_NORET' bit has been changed.
func_noret_changed(self, pfn)
pfn (C++: func_t *)
def func_tail_appended(self, *args) ‑> void
A function tail chunk has been appended.
func_tail_appended(self, pfn, tail)
pfn (C++: func_t *)
tail (C++: func_t *)
def func_tail_deleted(self, *args) ‑> void
A function tail chunk has been removed.
func_tail_deleted(self, pfn, tail_ea)
pfn (C++: func_t *)
tail_ea (C++: ea_t)
def func_updated(self, *args) ‑> void
The kernel has updated a function.
func_updated(self, pfn)
pfn (C++: func_t *)
def hook(self, *args) ‑> bool
hook(self) -> bool
def idasgn_loaded(self, *args) ‑> void
FLIRT signature has been loaded for normal processing (not for recognition of startup sequences).
idasgn_loaded(self, short_sig_name)
short_sig_name (C++: const char *)
def item_color_changed(self, *args) ‑> void
An item color has been changed.
item_color_changed(self, ea, color)
ea (C++: ea_t)
color: if color==DEFCOLOR, the the color is deleted. (C++:
bgcolor_t)
def kernel_config_loaded(self, *args) ‑> void
This event is issued when ida.cfg is parsed.
kernel_config_loaded(self, pass_number)
pass_number (C++: int)
def loader_finished(self, *args) ‑> void
External file loader finished its work. Use this event to augment the existing loader functionality.
loader_finished(self, li, neflags, filetypename)
li (C++: linput_t *)
neflags: Load file flags (C++: uint16)
filetypename (C++: const char *)
def local_types_changed(self, *args) ‑> void
Local types have been changed.
def make_code(self, *args) ‑> void
An instruction is being created.
make_code(self, insn)
insn (C++: const insn_t*)
def make_data(self, *args) ‑> void
A data item is being created.
make_data(self, ea, flags, tid, len)
ea (C++: ea_t)
flags (C++: flags_t)
tid (C++: tid_t)
len (C++: asize_t)
def op_ti_changed(self, *args) ‑> void
An operand typestring (c/c++ prototype) has been changed.
op_ti_changed(self, ea, n, type, fnames)
ea (C++: ea_t)
n (C++: int)
type (C++: const type_t *)
fnames (C++: const p_list *)
def op_type_changed(self, *args) ‑> void
An operand type (offset, hex, etc...) has been set or deleted.
op_type_changed(self, ea, n)
ea (C++: ea_t)
n: eventually or'ed with OPND_OUTER or OPND_ALL (C++: int)
def range_cmt_changed(self, *args) ‑> void
Range comment has been changed.
range_cmt_changed(self, kind, a, cmt, repeatable)
kind (C++: range_kind_t)
a (C++: const range_t *)
cmt (C++: const char *)
repeatable (C++: bool)
def renamed(self, *args) ‑> void
The kernel has renamed a byte. See also the \idpcode{rename} event
renamed(self, ea, new_name, local_name, old_name)
ea (C++: ea_t)
new_name: can be nullptr (C++: const char *)
local_name (C++: bool)
old_name: can be nullptr (C++: const char *)
def renaming_enum(self, *args) ‑> void
An enum or enum member is to be renamed.
renaming_enum(self, id, is_enum, newname)
id (C++: tid_t)
is_enum (C++: bool)
newname (C++: const char *)
def renaming_struc(self, *args) ‑> void
A structure type is to be renamed.
renaming_struc(self, id, oldname, newname)
id (C++: tid_t)
oldname (C++: const char *)
newname (C++: const char *)
def renaming_struc_member(self, *args) ‑> void
A structure member is to be renamed.
renaming_struc_member(self, sptr, mptr, newname)
sptr (C++: struc_t *)
mptr (C++: member_t *)
newname (C++: const char *)
def savebase(self, *args) ‑> void
The database is being saved.
def segm_added(self, *args) ‑> void
A new segment has been created.
segm_added(self, s)
s: See also adding_segm (C++: segment_t *)
def segm_attrs_updated(self, *args) ‑> void
Segment attributes has been changed.
segm_attrs_updated(self, s)
s: This event is generated for secondary segment attributes
(examples: color, permissions, etc) (C++: segment_t *)
def segm_class_changed(self, *args) ‑> void
Segment class has been changed.
segm_class_changed(self, s, sclass)
s (C++: segment_t *)
sclass (C++: const char *)
def segm_deleted(self, *args) ‑> void
A segment has been deleted.
segm_deleted(self, start_ea, end_ea)
start_ea (C++: ea_t)
end_ea (C++: ea_t)
def segm_end_changed(self, *args) ‑> void
Segment end address has been changed.
segm_end_changed(self, s, oldend)
s (C++: segment_t *)
oldend (C++: ea_t)
def segm_moved(self, *args) ‑> void
Segment has been moved.
segm_moved(self, _from, to, size, changed_netmap)
_from (C++: ea_t)
to (C++: ea_t)
size (C++: asize_t)
changed_netmap: See also idb_event::allsegs_moved (C++: bool)
def segm_name_changed(self, *args) ‑> void
Segment name has been changed.
segm_name_changed(self, s, name)
s (C++: segment_t *)
name (C++: const char *)
def segm_start_changed(self, *args) ‑> void
Segment start address has been changed.
segm_start_changed(self, s, oldstart)
s (C++: segment_t *)
oldstart (C++: ea_t)
def set_func_end(self, *args) ‑> void
Function chunk end address will be changed.
set_func_end(self, pfn, new_end)
pfn (C++: func_t *)
new_end (C++: ea_t)
def set_func_start(self, *args) ‑> void
Function chunk start address will be changed.
set_func_start(self, pfn, new_start)
pfn (C++: func_t *)
new_start (C++: ea_t)
def sgr_changed(self, *args) ‑> void
The kernel has changed a segment register value.
sgr_changed(self, start_ea, end_ea, regnum, value, old_value, tag)
start_ea (C++: ea_t)
end_ea (C++: ea_t)
regnum (C++: int)
value (C++: sel_t)
old_value (C++: sel_t)
tag: Segment register range tags (C++: uchar)
def sgr_deleted(self, *args) ‑> void
The kernel has deleted a segment register value.
sgr_deleted(self, start_ea, end_ea, regnum)
start_ea (C++: ea_t)
end_ea (C++: ea_t)
regnum (C++: int)
def stkpnts_changed(self, *args) ‑> void
Stack change points have been modified.
stkpnts_changed(self, pfn)
pfn (C++: func_t *)
def struc_align_changed(self, *args) ‑> void
A structure type has been changed (the struct alignment).
struc_align_changed(self, sptr)
sptr (C++: struc_t *)
def struc_cmt_changed(self, *args) ‑> void
A structure type comment has been changed.
struc_cmt_changed(self, struc_id, repeatable_cmt)
struc_id (C++: tid_t)
repeatable_cmt (C++: bool)
def struc_created(self, *args) ‑> void
A new structure type has been created.
struc_created(self, struc_id)
struc_id (C++: tid_t)
def struc_deleted(self, *args) ‑> void
A structure type has been deleted.
struc_deleted(self, struc_id)
struc_id (C++: tid_t)
def struc_expanded(self, *args) ‑> void
A structure type has been expanded/shrank.
struc_expanded(self, sptr)
sptr (C++: struc_t *)
def struc_member_changed(self, *args) ‑> void
A structure member has been changed.
struc_member_changed(self, sptr, mptr)
sptr (C++: struc_t *)
mptr (C++: member_t *)
def struc_member_created(self, *args) ‑> void
A structure member has been created.
struc_member_created(self, sptr, mptr)
sptr (C++: struc_t *)
mptr (C++: member_t *)
def struc_member_deleted(self, *args) ‑> void
A structure member has been deleted.
struc_member_deleted(self, sptr, member_id, offset)
sptr (C++: struc_t *)
member_id (C++: tid_t)
offset (C++: ea_t)
def struc_member_renamed(self, *args) ‑> void
A structure member has been renamed.
struc_member_renamed(self, sptr, mptr)
sptr (C++: struc_t *)
mptr (C++: member_t *)
def struc_renamed(self, *args) ‑> void
A structure type has been renamed.
struc_renamed(self, sptr)
sptr (C++: struc_t *)
def tail_owner_changed(self, *args) ‑> void
A tail chunk owner has been changed.
tail_owner_changed(self, tail, owner_func, old_owner)
tail (C++: func_t *)
owner_func (C++: ea_t)
old_owner (C++: ea_t)
def thunk_func_created(self, *args) ‑> void
A thunk bit has been set for a function.
thunk_func_created(self, pfn)
pfn (C++: func_t *)
def ti_changed(self, *args) ‑> void
An item typestring (c/c++ prototype) has been changed.
ti_changed(self, ea, type, fnames)
ea (C++: ea_t)
type (C++: const type_t *)
fnames (C++: const p_list *)
def tryblks_updated(self, *args) ‑> void
Updated tryblk information
tryblks_updated(self, tbv)
tbv (C++: const tryblks_t *)
def unhook(self, *args) ‑> bool
unhook(self) -> bool
def updating_tryblks(self, *args) ‑> void
About to update tryblk information
updating_tryblks(self, tbv)
tbv (C++: const tryblks_t *)
def upgraded(self, *args) ‑> void
The database has been upgraded and the receiver can upgrade its info as well
upgraded(self, _from)
_from: - old IDB version (C++: int)
class IDP_Hooks (*args)
Proxy of C++ IDP_Hooks class.
__init__(self, _flags=0) -> IDP_Hooks
_flags: uint32

Subclasses

  • ida_idp._notify_when_dispatcher_t._IDP_Hooks
  • processor_t

Methods

def ev_add_cref(self, *args) ‑> int
A code reference is being created.
ev_add_cref(self, _from, to, type) -> int
_from (C++: ea_t)
to (C++: ea_t)
type (C++: cref_t)
retval: <0 - cancel cref creation
retval: 0 - not implemented or continue
def ev_add_dref(self, *args) ‑> int
A data reference is being created.
ev_add_dref(self, _from, to, type) -> int
_from (C++: ea_t)
to (C++: ea_t)
type (C++: dref_t)
retval: <0 - cancel dref creation
retval: 0 - not implemented or continue
def ev_adjust_argloc(self, *args) ‑> int
Adjust argloc according to its type/size and platform endianess
ev_adjust_argloc(self, argloc, optional_type, size) -> int
argloc: , inout (C++: argloc_t *) optional_type: tinfo_t const *
size: 'size' makes no sense if type != NULL (type->get_size()
should be used instead) (C++: int)
retval: 0 - not implemented
retval: 1 - ok
retval: -1 - error
def ev_adjust_libfunc_ea(self, *args) ‑> int
Called when a signature module has been matched against bytes in the database. This is used to compute the offset at which a particular module's libfunc should be applied.'ea' initially contains the ea_t of the start of the pattern match
ev_adjust_libfunc_ea(self, sig, libfun, ea) -> int
sig (C++: const idasgn_t *)
libfun (C++: const libfunc_t *)
ea (C++: ea_t *)
retval: 1 - the ea_t pointed to by the third argument was modified.
retval: <=0 - not modified. use default algorithm.
def ev_adjust_refinfo(self, *args) ‑> int
Called from apply_fixup before converting operand to reference. Can be used for changing the reference info. (e.g. the PPC module adds REFINFO_NOBASE for some references)
ev_adjust_refinfo(self, ri, ea, n, fd) -> int
ri (C++: refinfo_t *)
ea: instruction address (C++: ea_t)
n: operand number (C++: int)
fd (C++: const fixup_data_t *)
retval: <0 - do not create an offset
retval: 0 - not implemented or refinfo adjusted
def ev_ana_insn(self, *args) ‑> bool
Analyze one instruction and fill 'out' structure. This function shouldn't change the database, flags or anything else. All these actions should be performed only by emu_insn() function. \insn_t{ea}
contains address of instruction to analyze.
ev_ana_insn(self, out) -> bool
out (C++: insn_t *)
retval: 0 - if instruction can't be decoded.
def ev_analyze_prolog(self, *args) ‑> int
Analyzes function prolog, epilog, and updates purge, and function attributes
ev_analyze_prolog(self, ea) -> int
ea: start of function (C++: ea_t)
retval: 1 - ok
retval: 0 - not implemented
def ev_arch_changed(self, *args) ‑> int
The loader is done parsing arch-related information, which the processor module might want to use to finish its initialization.
def ev_arg_addrs_ready(self, *args) ‑> int
Argument address info is ready.
ev_arg_addrs_ready(self, caller, n, tif, addrs) -> int
caller (C++: ea_t)
n: number of formal arguments (C++: int)
tif: call prototype (C++: tinfo_t *)
addrs: argument intilization addresses (C++: ea_t *)
retval: <0 - do not save into idb; other values mean "ok to save"
def ev_asm_installed(self, *args) ‑> int
After setting a new assembler
ev_asm_installed(self, asmnum) -> int
asmnum: See also ev_newasm (C++: int)
def ev_assemble(self, *args) ‑> PyObject *
Assemble an instruction. (display a warning if an error is found).
ev_assemble(self, ea, cs, ip, use32, line) -> PyObject *
ea: linear address of instruction (C++: ea_t)
cs: cs of instruction (C++: ea_t)
ip: ip of instruction (C++: ea_t)
use32: is 32bit segment? (C++: bool)
line: line to assemble (C++: const char *)
def ev_auto_queue_empty(self, *args) ‑> int
One analysis queue is empty.
ev_auto_queue_empty(self, type) -> int
type (C++: atype_t)
retval: void - see also idb_event::auto_empty_finally
def ev_calc_arglocs(self, *args) ‑> int
Calculate function argument locations. This callback should fill retloc, all arglocs, and stkargs. This callback is never called for 'CM_CC_SPECIAL' functions.
ev_calc_arglocs(self, fti) -> int
fti: points to the func type info (C++: func_type_data_t *)
retval: 0 - not implemented
retval: 1 - ok
retval: -1 - error
def ev_calc_cdecl_purged_bytes(self, *args) ‑> int
Calculate number of purged bytes after call.
ev_calc_cdecl_purged_bytes(self, ea) -> int
ea: address of the call instruction (C++: ea_t)
return: number of purged bytes (usually add sp, N)
def ev_calc_next_eas(self, *args) ‑> int
Calculate list of addresses the instruction in 'insn' may pass control to. This callback is required for source level debugging.
ev_calc_next_eas(self, res, insn, over) -> int
res: , out: array for the results. (C++: eavec_t *)
insn: the instruction (C++: const insn_t*)
over: calculate for step over (ignore call targets) (C++:
bool)
retval: <0 - incalculable (indirect jumps, for example)
retval: >=0 - number of addresses of called functions in the array.
They must be put at the beginning of the array (0 if over=true)
def ev_calc_purged_bytes(self, *args) ‑> int
Calculate number of purged bytes by the given function type.
ev_calc_purged_bytes(self, p_purged_bytes, fti) -> int
p_purged_bytes: ptr to output (C++: int *)
fti: func type details (C++: const func_type_data_t *)
retval: 1 -
retval: 0 - not implemented
def ev_calc_retloc(self, *args) ‑> int
Calculate return value location.
ev_calc_retloc(self, retloc, rettype, cc) -> int
retloc (C++: argloc_t *)
rettype (C++: const tinfo_t *)
cc (C++: cm_t)
retval: 0 - not implemented
retval: 1 - ok,
retval: -1 - error
def ev_calc_spdelta(self, *args) ‑> int
Calculate amount of change to sp for the given insn. This event is required to decompile code snippets.
ev_calc_spdelta(self, spdelta, insn) -> int
spdelta (C++: sval_t *)
insn (C++: const insn_t *)
retval: 1 - ok
retval: 0 - not implemented
def ev_calc_step_over(self, *args) ‑> int
Calculate the address of the instruction which will be executed after "step over". The kernel will put a breakpoint there. If the step over is equal to step into or we cannot calculate the address, return 'BADADDR' .
ev_calc_step_over(self, target, ip) -> int
target: pointer to the answer (C++: ea_t *)
ip: instruction address (C++: ea_t)
retval: 0 - unimplemented
retval: 1 - implemented
def ev_calc_switch_cases(self, *args) ‑> int
Calculate case values and targets for a custom jump table.
ev_calc_switch_cases(self, casevec, targets, insn_ea, si) -> int
casevec: vector of case values (may be NULL) (C++: casevec_t
*)
targets: corresponding target addresses (my be NULL) (C++:
eavec_t *)
insn_ea: address of the 'indirect jump' instruction (C++:
ea_t)
si: switch information (C++: switch_info_t *)
retval: 1 - ok
retval: <=0 - failed
def ev_calc_varglocs(self, *args) ‑> int
Calculate locations of the arguments that correspond to '...'.
ev_calc_varglocs(self, ftd, aux_regs, aux_stkargs, nfixed) -> int
ftd: , inout: info about all arguments (including varargs)
(C++: func_type_data_t *)
aux_regs: buffer for hidden register arguments, may be NULL
(C++: regobjs_t *)
aux_stkargs: buffer for hidden stack arguments, may be NULL
(C++: relobj_t *)
nfixed: number of fixed arguments (C++: int)
retval: 0 - not implemented
retval: 1 - ok
retval: -1 - error On some platforms variadic calls require passing
additional information: for example, number of floating variadic arguments must be passed in rax on gcc-x64. The locations and values that constitute this additional information are returned in the buffers pointed by aux_regs and aux_stkargs
def ev_calcrel(self, *args) ‑> int
Reserved.
def ev_can_have_type(self, *args) ‑> int
Can the operand have a type as offset, segment, decimal, etc? (for example, a register AX can't have a type, meaning that the user can't change its representation. see 'bytes.hpp' for information about types and flags)
ev_can_have_type(self, op) -> int
op (C++: const op_t *)
retval: 0 - unknown
retval: <0 - no
retval: 1 - yes
def ev_clean_tbit(self, *args) ‑> int
Clear the TF bit after an insn like pushf stored it in memory.
ev_clean_tbit(self, ea, getreg, regvalues) -> int
ea: instruction address (C++: ea_t)
getreg: function to get register values (C++:
processor_t::regval_getter_t *)
regvalues: register values array (C++: const regval_t *)
retval: 1 - ok
retval: 0 - failed
def ev_cmp_operands(self, *args) ‑> int
Compare instruction operands
ev_cmp_operands(self, op1, op2) -> int
op1 (C++: const op_t*)
op2 (C++: const op_t*)
retval: 1 - equal
retval: -1 - not equal
retval: 0 - not implemented
def ev_coagulate(self, *args) ‑> int
Try to define some unexplored bytes. This notification will be called if the kernel tried all possibilities and could not find anything more useful than to convert to array of bytes. The module can help the kernel and convert the bytes into something more useful.
ev_coagulate(self, start_ea) -> int
start_ea (C++: ea_t)
return: number of converted bytes
def ev_coagulate_dref(self, *args) ‑> int
Data reference is being analyzed. plugin may correct 'code_ea' (e.g. for thumb mode refs, we clear the last bit)
ev_coagulate_dref(self, _from, to, may_define, code_ea) -> int
_from (C++: ea_t)
to (C++: ea_t)
may_define (C++: bool)
code_ea (C++: ea_t *)
retval: <0 - failed dref analysis, >0 done dref analysis
retval: 0 - not implemented or continue
def ev_create_flat_group(self, *args) ‑> int
Create special segment representing the flat group.
ev_create_flat_group(self, image_base, bitness, dataseg_sel) -> int
image_base (C++: ea_t)
bitness (C++: int)
dataseg_sel: return value is ignored (C++: sel_t)
def ev_create_func_frame(self, *args) ‑> int
Create a function frame for a newly created function Set up frame size, its attributes etc
ev_create_func_frame(self, pfn) -> int
pfn (C++: func_t *)
retval: 1 - ok
retval: 0 - not implemented
def ev_create_merge_handlers(self, *args) ‑> int
Create merge handlers, if needed
ev_create_merge_handlers(self, md) -> int
md: This event is generated immediately after opening idbs.
(C++: merge_data_t *)
return: must be 0
def ev_create_switch_xrefs(self, *args) ‑> int
Create xrefs for a custom jump table.
ev_create_switch_xrefs(self, jumpea, si) -> int
jumpea: address of the jump insn (C++: ea_t)
si: switch information (C++: const switch_info_t *)
return: must return 1 Must be implemented if module uses custom jump
tables,
def ev_creating_segm(self, *args) ‑> int
A new segment is about to be created.
ev_creating_segm(self, seg) -> int
seg (C++: segment_t *)
retval: 1 - ok
retval: <0 - segment should not be created
def ev_decorate_name(self, *args) ‑> PyObject *
Decorate/undecorate a C symbol name.
ev_decorate_name(self, name, mangle, cc, optional_type) -> PyObject *
name: name of symbol (C++: const char *)
mangle: true-mangle, false-unmangle (C++: bool)
cc: calling convention (C++: cm_t) optional_type: tinfo_t const *
retval: 1 - if success
retval: 0 - not implemented or failed
def ev_del_cref(self, *args) ‑> int
A code reference is being deleted.
ev_del_cref(self, _from, to, expand) -> int
_from (C++: ea_t)
to (C++: ea_t)
expand (C++: bool)
retval: <0 - cancel cref deletion
retval: 0 - not implemented or continue
def ev_del_dref(self, *args) ‑> int
A data reference is being deleted.
ev_del_dref(self, _from, to) -> int
_from (C++: ea_t)
to (C++: ea_t)
retval: <0 - cancel dref deletion
retval: 0 - not implemented or continue
def ev_delay_slot_insn(self, *args) ‑> PyObject *
Get delay slot instructionInput EA may point to the instruction with a delay slot or to the delay slot instruction itself.
ev_delay_slot_insn(self, ea, bexec, fexec) -> PyObject *
ea: in: instruction address in question, out: (if the answer is
positive) if the delay slot contains valid insn: the address of the delay slot insn else: BADADDR (invalid insn, e.g. a branch) (C++: ea_t *)
bexec: execute slot if jumping, initially set to 'true' (C++:
bool *)
fexec: execute slot if not jumping, initally set to 'true'
(C++: bool *)
retval: 1 - positive answer
retval: <=0 - ordinary insn
def ev_demangle_name(self, *args) ‑> PyObject *
Demangle a C++ (or another language) name into a user-readable string. This event is called by 'demangle_name()' if you call 'demangle_name()' from the handler, protect against recursion!
ev_demangle_name(self, name, disable_mask, demreq) -> PyObject *
name: mangled name (C++: const char *)
disable_mask: flags to inhibit parts of output or compiler
info/other (see MNG_) (C++: uint32)
demreq: operation to perform (C++: demreq_type_t)
retval: 1 - if success
retval: 0 - not implemented
def ev_emu_insn(self, *args) ‑> bool
Emulate instruction, create cross-references, plan to analyze subsequent instructions, modify flags etc. Upon entrance to this function, all information about the instruction is in 'insn' structure.
ev_emu_insn(self, insn) -> bool
insn (C++: const insn_t *)
retval: 1 - ok
retval: -1 - the kernel will delete the instruction
def ev_endbinary(self, *args) ‑> int
IDA has loaded a binary file.
ev_endbinary(self, ok) -> int
ok: file loaded successfully? (C++: bool)
def ev_ending_undo(self, *args) ‑> int
Ended undoing/redoing an action
ev_ending_undo(self, action_name, is_undo) -> int
action_name: action that we finished undoing/redoing. is not
NULL. (C++: const char *)
is_undo: true if performing undo, false if performing redo
(C++: bool)
def ev_equal_reglocs(self, *args) ‑> int
Are 2 register arglocs the same?. We need this callback for the pc module.
ev_equal_reglocs(self, a1, a2) -> int
a1 (C++: argloc_t *)
a2 (C++: argloc_t *)
retval: 1 - yes
retval: -1 - no
retval: 0 - not implemented
def ev_extract_address(self, *args) ‑> int
Extract address from a string.
ev_extract_address(self, out_ea, screen_ea, string, position) -> int
out_ea: , out (C++: ea_t *)
screen_ea (C++: ea_t)
string (C++: const char *)
position (C++: size_t)
retval: 1 - ok
retval: 0 - kernel should use the standard algorithm
retval: -1 - error
def ev_find_op_value(self, *args) ‑> PyObject *
Find operand value via a register tracker. The returned value in 'out' is valid before executing the instruction.
ev_find_op_value(self, pinsn, opn) -> PyObject *
pinsn: instruction (C++: const insn_t *)
opn: operand index (C++: int)
retval: 1 - if implemented, and value was found
retval: 0 - not implemented, -1 decoding failed, or no value found
def ev_find_reg_value(self, *args) ‑> PyObject *
Find register value via a register tracker. The returned value in 'out' is valid before executing the instruction.
ev_find_reg_value(self, pinsn, reg) -> PyObject *
pinsn: instruction (C++: const insn_t *)
reg: register index (C++: int)
retval: 1 - if implemented, and value was found
retval: 0 - not implemented, -1 decoding failed, or no value found
def ev_func_bounds(self, *args) ‑> int
'find_func_bounds()' finished its work. The module may fine tune the function bounds
ev_func_bounds(self, possible_return_code, pfn, max_func_end_ea) -> int
possible_return_code: , in/out (C++: int *)
pfn (C++: func_t *)
max_func_end_ea: (from the kernel's point of view) (C++: ea_t)
retval: void -
def ev_gen_asm_or_lst(self, *args) ‑> int
Callback: generating asm or lst file. The kernel calls this callback twice, at the beginning and at the end of listing generation. The processor module can intercept this event and adjust its output
ev_gen_asm_or_lst(self, starting, fp, is_asm, flags, outline) -> int
starting: beginning listing generation (C++: bool)
fp: output file (C++: FILE *)
is_asm: true:assembler, false:listing (C++: bool)
flags: flags passed to gen_file() (C++: int)
outline: ptr to ptr to outline callback. if this callback is
defined for this code, it will be used by the kernel to output the generated lines (C++: html_line_cb_t **)
retval: void -
def ev_gen_map_file(self, *args) ‑> int
Generate map file. If not implemented the kernel itself will create the map file.
ev_gen_map_file(self, nlines, fp) -> int
nlines: number of lines in map file (-1 means write error)
(C++: int *)
fp: output file (C++: FILE *)
retval: 0 - not implemented
retval: 1 - ok
retval: -1 - write error
def ev_gen_regvar_def(self, *args) ‑> int
Generate register variable definition line.
ev_gen_regvar_def(self, outctx, v) -> int
outctx (C++: outctx_t *)
v (C++: regvar_t *)
retval: >0 - ok, generated the definition text
retval: 0 - not implemented
def ev_gen_src_file_lnnum(self, *args) ‑> int
Callback: generate analog of:
< #line "file.c" 123 <
directive.
ev_gen_src_file_lnnum(self, outctx, file, lnnum) -> int
outctx: output context (C++: outctx_t *)
file: source file (may be NULL) (C++: const char *)
lnnum: line number (C++: size_t)
retval: 1 - directive has been generated
retval: 0 - not implemented
def ev_gen_stkvar_def(self, *args) ‑> int
Generate stack variable definition line Default line is varname = type ptr value, where 'type' is one of byte,word,dword,qword,tbyte
ev_gen_stkvar_def(self, outctx, mptr, v) -> int
outctx (C++: outctx_t *)
mptr (C++: const member_t *)
v (C++: sval_t)
retval: 1 - ok
retval: 0 - not implemented
def ev_get_abi_info(self, *args) ‑> int
Get all possible ABI names and optional extensions for given compiler abiname/option is a string entirely consisting of letters, digits and underscore
ev_get_abi_info(self, abi_names, abi_opts, comp) -> int
abi_names: - all possible ABis each in form
abiname-opt1-opt2-... (C++: qstrvec_t *)
abi_opts: - array of all possible options in form
"opt:description" or opt:hint-line#description (C++: qstrvec_t *)
comp: - compiler ID (C++: comp_t)
retval: 0 - not implemented
retval: 1 - ok
def ev_get_autocmt(self, *args) ‑> PyObject *
Callback: get dynamic auto comment. Will be called if the autocomments are enabled and the comment retrieved from ida.int starts with '$!'. 'insn' contains valid info.
ev_get_autocmt(self, insn) -> PyObject *
insn: the instruction (C++: const insn_t*)
retval: 1 - new comment has been generated
retval: 0 - callback has not been handled. the buffer must not be
changed in this case
def ev_get_bg_color(self, *args) ‑> int
Get item background color. Plugins can hook this callback to color disassembly lines dynamically
ev_get_bg_color(self, ea) -> int or None
color: , out (C++: bgcolor_t *)
ea (C++: ea_t)
retval: 0 - not implemented
retval: 1 - color set
def ev_get_cc_regs(self, *args) ‑> int
Get register allocation convention for given calling convention
ev_get_cc_regs(self, regs, cc) -> int
regs: , out (C++: callregs_t *)
cc (C++: cm_t)
retval: 1 -
retval: 0 - not implemented
def ev_get_code16_mode(self, *args) ‑> int
Get ISA 16-bit mode
ev_get_code16_mode(self, ea) -> int
ea: address to get the ISA mode (C++: ea_t)
retval: 1 - 16-bit mode
retval: 0 - not implemented or 32-bit mode
def ev_get_dbr_opnum(self, *args) ‑> int
Get the number of the operand to be displayed in the debugger reference view (text mode).
ev_get_dbr_opnum(self, opnum, insn) -> int
opnum: operand number (out, -1 means no such operand) (C++:
int *)
insn: the instruction (C++: const insn_t*)
retval: 0 - unimplemented
retval: 1 - implemented
def ev_get_default_enum_size(self, *args) ‑> int
Get default enum size. Not generated anymore. inf_get_cc_size_e() is used instead
def ev_get_frame_retsize(self, *args) ‑> int
Get size of function return address in bytes If this event is not implemented, the kernel will assume8 bytes for 64-bit function4 bytes for 32-bit function2 bytes otherwise
ev_get_frame_retsize(self, frsize, pfn) -> int
frsize: frame size (out) (C++: int *)
pfn: , can't be NULL (C++: const func_t *)
def ev_get_macro_insn_head(self, *args) ‑> int
Calculate the start of a macro instruction. This notification is called if IP points to the middle of an instruction
ev_get_macro_insn_head(self, head, ip) -> int
head: , out: answer, BADADDR means normal instruction (C++:
ea_t *)
ip: instruction address (C++: ea_t)
retval: 0 - unimplemented
retval: 1 - implemented
def ev_get_operand_string(self, *args) ‑> PyObject *
Request text string for operand (cli, java, ...).
ev_get_operand_string(self, insn, opnum) -> PyObject *
insn: the instruction (C++: const insn_t*)
opnum: operand number, -1 means any string operand (C++: int)
retval: 0 - no string (or empty string)
retval: >0 - original string length without terminating zero
def ev_get_procmod(self, *args) ‑> int
Get pointer to the processor module object. All processor modules must implement this. The pointer is returned as size_t.
def ev_get_reg_accesses(self, *args) ‑> int
Get info about the registers that are used/changed by an instruction.
ev_get_reg_accesses(self, accvec, insn, flags) -> int
accvec: out: info about accessed registers (C++:
reg_accesses_t*)
insn: instruction in question (C++: const insn_t *)
flags: reserved, must be 0 (C++: int)
retval: -1 - if accvec is nullptr
retval: 1 - found the requested access (and filled accvec)
retval: 0 - not implemented
def ev_get_reg_info(self, *args) ‑> int
Get register information by its name. example: "ah" returns:main_regname="eax" 'bitrange_t' = { offset==8, nbits==8 }This callback may be unimplemented if the register names are all present in
\ph{reg_names}
and they all have the same size
ev_get_reg_info(self, main_regname, bitrange, regname) -> int
main_regname: , out (C++: const char **)
bitrange: , out: position and size of the value within
'main_regname' (empty bitrange == whole register) (C++: bitrange_t *)
regname (C++: const char *)
retval: 1 - ok
retval: -1 - failed (not found)
retval: 0 - unimplemented
def ev_get_reg_name(self, *args) ‑> PyObject *
Generate text representation of a register. Most processor modules do not need to implement this callback. It is useful only if
\ph{reg_names}
[reg] does not provide the correct register name.
ev_get_reg_name(self, reg, width, reghi) -> PyObject *
reg: internal register number as defined in the processor
module (C++: int)
width: register width in bytes (C++: size_t)
reghi: if not -1 then this function will return the register
pair (C++: int)
retval: -1 - if error
retval: strlen(buf) - if success
def ev_get_simd_types(self, *args) ‑> int
Get SIMD-related types according to given attributes ant/or argument location
ev_get_simd_types(self, out, simd_attrs, argloc, create_tifs) -> int
out (C++: simd_info_vec_t *)
simd_attrs: , may be NULL (C++: const simd_info_t *)
argloc: , may be NULL (C++: const argloc_t *)
create_tifs: return valid tinfo_t objects, create if neccessary
(C++: bool)
retval: number - of found types
retval: -1 - error If name==NULL, initialize all SIMD types
def ev_get_stkarg_offset(self, *args) ‑> int
Get offset from SP to the first stack argument. For example: pc: 0, hppa: -0x34, ppc: 0x38
def ev_get_stkvar_scale_factor(self, *args) ‑> int
Should stack variable references be multiplied by a coefficient before being used in the stack frame?. Currently used by TMS320C55 because the references into the stack should be multiplied by 2 'PR_SCALE_STKVARS' should be set to use this callback
def ev_getreg(self, *args) ‑> int
IBM PC only internal request, should never be used for other purpose Get register value by internal index
ev_getreg(self, regval, regnum) -> int
regval: , out (C++: uval_t *)
regnum (C++: int)
retval: 1 - ok
retval: 0 - not implemented
retval: -1 - failed (undefined value or bad regnum)
def ev_init(self, *args) ‑> int
The IDP module is just loaded.
ev_init(self, idp_modname) -> int
idp_modname: processor module name (C++: const char *)
retval: <0 - on failure
def ev_insn_reads_tbit(self, *args) ‑> int
Check if insn will read the TF bit.
ev_insn_reads_tbit(self, insn, getreg, regvalues) -> int
insn: the instruction (C++: const insn_t*)
getreg: function to get register values (C++:
processor_t::regval_getter_t *)
regvalues: register values array (C++: const regval_t *)
retval: 2 - yes, will generate 'step' exception
retval: 1 - yes, will store the TF bit in memory
retval: 0 - no
def ev_is_align_insn(self, *args) ‑> int
Is the instruction created only for alignment purposes?. Do not directly call this function, use 'is_align_insn()'
ev_is_align_insn(self, ea) -> int
ea: - instruction address (C++: ea_t)
retval: number - of bytes in the instruction
def ev_is_alloca_probe(self, *args) ‑> int
Does the function at 'ea' behave as __alloca_probe?
ev_is_alloca_probe(self, ea) -> int
ea (C++: ea_t)
retval: 1 - yes
retval: 0 - no
def ev_is_basic_block_end(self, *args) ‑> int
Is the current instruction end of a basic block?. This function should be defined for processors with delayed jump slots.
ev_is_basic_block_end(self, insn, call_insn_stops_block) -> int
insn: the instruction (C++: const insn_t*)
call_insn_stops_block (C++: bool)
retval: 0 - unknown
retval: <0 - no
retval: 1 - yes
def ev_is_call_insn(self, *args) ‑> int
Is the instruction a "call"?
ev_is_call_insn(self, insn) -> int
insn: instruction (C++: const insn_t *)
retval: 0 - unknown
retval: <0 - no
retval: 1 - yes
def ev_is_cond_insn(self, *args) ‑> int
Is conditional instruction?
ev_is_cond_insn(self, insn) -> int
insn: instruction address (C++: const insn_t *)
retval: 1 - yes
retval: -1 - no
retval: 0 - not implemented or not instruction
def ev_is_control_flow_guard(self, *args) ‑> int
Detect if an instruction is a "thunk call" to a flow guard function (equivalent to call reg/return/nop)
ev_is_control_flow_guard(self, p_reg, insn) -> int
p_reg: indirect register number, may be -1 (C++: int *)
insn: call/jump instruction (C++: const insn_t *)
retval: -1 - no thunk detected
retval: 1 - indirect call
retval: 2 - security check routine call (NOP)
retval: 3 - return thunk
retval: 0 - not implemented
def ev_is_far_jump(self, *args) ‑> int
is indirect far jump or call instruction? meaningful only if the processor has 'near' and 'far' reference types
ev_is_far_jump(self, icode) -> int
icode (C++: int)
retval: 0 - not implemented
retval: 1 - yes
retval: -1 - no
def ev_is_indirect_jump(self, *args) ‑> int
Determine if instruction is an indirect jump. If 'CF_JUMP' bit cannot describe all jump types jumps, please define this callback.
ev_is_indirect_jump(self, insn) -> int
insn: the instruction (C++: const insn_t*)
retval: 0 - use CF_JUMP
retval: 1 - no
retval: 2 - yes
def ev_is_insn_table_jump(self, *args) ‑> int
Reserved.
def ev_is_jump_func(self, *args) ‑> int
Is the function a trivial "jump" function?.
ev_is_jump_func(self, pfn, jump_target, func_pointer) -> int
pfn (C++: func_t *)
jump_target (C++: ea_t *)
func_pointer (C++: ea_t *)
retval: <0 - no
retval: 0 - don't know
retval: 1 - yes, see 'jump_target' and 'func_pointer'
def ev_is_ret_insn(self, *args) ‑> int
Is the instruction a "return"?
ev_is_ret_insn(self, insn, strict) -> int
insn: instruction (C++: const insn_t *)
strict: 1: report only ret instructions 0: include instructions
like "leave" which begins the function epilog (C++: bool)
retval: 0 - unknown
retval: <0 - no
retval: 1 - yes
def ev_is_sane_insn(self, *args) ‑> int
Is the instruction sane for the current file type?.
ev_is_sane_insn(self, insn, no_crefs) -> int
insn: the instruction (C++: const insn_t*)
no_crefs: 1: the instruction has no code refs to it. ida just
tries to convert unexplored bytes to an instruction (but there is no other reason to convert them into an instruction) 0: the instruction is created because of some coderef, user request or another weighty reason. (C++: int)
retval: >=0 - ok
retval: <0 - no, the instruction isn't likely to appear in the
program
def ev_is_sp_based(self, *args) ‑> int
Check whether the operand is relative to stack pointer or frame pointer This event is used to determine how to output a stack variable If not implemented, then all operands are sp based by default. Implement this event only if some stack references use frame pointer instead of stack pointer.
ev_is_sp_based(self, mode, insn, op) -> int
mode: out, combination of SP/FP operand flags (C++: int *)
insn (C++: const insn_t *)
op (C++: const op_t *)
retval: 0 - not implemented
retval: 1 - ok
def ev_is_switch(self, *args) ‑> int
Find 'switch' idiom. It will be called for instructions marked with 'CF_JUMP' .
ev_is_switch(self, si, insn) -> int
si: , out (C++: switch_info_t *)
insn: instruction possibly belonging to a switch (C++: const
insn_t *)
retval: 1 - switch is found, 'si' is filled
retval: -1 - no switch found
retval: 0 - not implemented
def ev_last_cb_before_loader(self, *args) ‑> int
ev_last_cb_before_loader(self) -> int
def ev_loader(self, *args) ‑> int
This code and higher ones are reserved for the loaders. The arguments and the return values are defined by the loaders
def ev_lower_func_type(self, *args) ‑> int
Get function arguments which should be converted to pointers when lowering function prototype. The processor module can also modify 'fti' in order to make non-standard conversion of some arguments.
ev_lower_func_type(self, argnums, fti) -> int
argnums: , out - numbers of arguments to be converted to
pointers in acsending order (C++: intvec_t *)
fti: , inout func type details (special values -1/-2 for return
value - position of hidden 'retstr' argument: -1 - at the beginning, -2 - at the end) (C++: func_type_data_t *)
retval: 0 - not implemented
retval: 1 - argnums was filled
retval: 2 - argnums was filled and made substantial changes to fti
def ev_max_ptr_size(self, *args) ‑> int
Get maximal size of a pointer in bytes.
def ev_may_be_func(self, *args) ‑> int
Can a function start here?
ev_may_be_func(self, insn, state) -> int
insn: the instruction (C++: const insn_t*)
state: autoanalysis phase 0: creating functions 1: creating
chunks (C++: int)
return: probability 1..100
def ev_may_show_sreg(self, *args) ‑> int
The kernel wants to display the segment registers in the messages window.
ev_may_show_sreg(self, current_ea) -> int
current_ea (C++: ea_t)
retval: <0 - if the kernel should not show the segment registers.
(assuming that the module has done it)
retval: 0 - not implemented
def ev_moving_segm(self, *args) ‑> int
May the kernel move the segment?
ev_moving_segm(self, seg, to, flags) -> int
seg: segment to move (C++: segment_t *)
to: new segment start address (C++: ea_t)
flags: combination of Move segment flags (C++: int)
retval: 0 - yes
retval: <0 - the kernel should stop
def ev_newasm(self, *args) ‑> int
Before setting a new assembler.
ev_newasm(self, asmnum) -> int
asmnum: See also ev_asm_installed (C++: int)
def ev_newbinary(self, *args) ‑> int
IDA is about to load a binary file.
ev_newbinary(self, filename, fileoff, basepara, binoff, nbytes) -> int
filename: binary file name (C++: char *)
fileoff: offset in the file (C++: qoff64_t)
basepara: base loading paragraph (C++: ea_t)
binoff: loader offset (C++: ea_t)
nbytes: number of bytes to load (C++: uint64)
def ev_newfile(self, *args) ‑> int
A new file has been loaded.
ev_newfile(self, fname) -> int
fname: input file name (C++: char *)
def ev_newprc(self, *args) ‑> int
Before changing processor type.
ev_newprc(self, pnum, keep_cfg) -> int
pnum: processor number in the array of processor names (C++:
int)
keep_cfg: true: do not modify kernel configuration (C++: bool)
retval: 1 - ok
retval: <0 - prohibit
def ev_next_exec_insn(self, *args) ‑> int
Get next address to be executed This function must return the next address to be executed. If the instruction following the current one is executed, then it must return 'BADADDR' Usually the instructions to consider are: jumps, branches, calls, returns. This function is essential if the 'single step' is not supported in hardware.
ev_next_exec_insn(self, target, ea, tid, getreg, regvalues) -> int
target: , out: pointer to the answer (C++: ea_t *)
ea: instruction address (C++: ea_t)
tid: current therad id (C++: int)
getreg: function to get register values (C++:
processor_t::regval_getter_t *)
regvalues: register values array (C++: const regval_t *)
retval: 0 - unimplemented
retval: 1 - implemented
def ev_oldfile(self, *args) ‑> int
An old file has been loaded.
ev_oldfile(self, fname) -> int
fname: input file name (C++: char *)
def ev_out_assumes(self, *args) ‑> int
Function to produce assume directives when segment register value changes.
ev_out_assumes(self, outctx) -> int
outctx (C++: outctx_t *)
retval: 1 - ok
retval: 0 - not implemented
def ev_out_data(self, *args) ‑> int
Generate text representation of data items This function may change the database and create cross-references if analyze_only is set
ev_out_data(self, outctx, analyze_only) -> int
outctx (C++: outctx_t *)
analyze_only (C++: bool)
retval: 1 - ok
retval: 0 - not implemented
Function to produce end of disassembled text
ev_out_footer(self, outctx) -> int
outctx (C++: outctx_t *)
retval: void -
def ev_out_header(self, *args) ‑> int
Function to produce start of disassembled text
ev_out_header(self, outctx) -> int
outctx (C++: outctx_t *)
retval: void -
def ev_out_insn(self, *args) ‑> bool
Generate text representation of an instruction in 'ctx.insn' 'outctx_t' provides functions to output the generated text. This function shouldn't change the database, flags or anything else. All these actions should be performed only by emu_insn() function.
ev_out_insn(self, outctx) -> bool
outctx (C++: outctx_t *)
retval: void -
def ev_out_label(self, *args) ‑> int
The kernel is going to generate an instruction label line or a function header.
ev_out_label(self, outctx, colored_name) -> int
outctx (C++: outctx_t *)
colored_name (C++: const char *)
retval: <0 - if the kernel should not generate the label
retval: 0 - not implemented or continue
def ev_out_mnem(self, *args) ‑> int
Generate instruction mnemonics. This callback should append the colored mnemonics to ctx.outbuf Optional notification, if absent, out_mnem will be called.
ev_out_mnem(self, outctx) -> int
outctx (C++: outctx_t *)
retval: 1 - if appended the mnemonics
retval: 0 - not implemented
def ev_out_operand(self, *args) ‑> bool
Generate text representation of an instruction operand 'outctx_t' provides functions to output the generated text. All these actions should be performed only by emu_insn() function.
ev_out_operand(self, outctx, op) -> bool
outctx (C++: outctx_t *)
op (C++: const op_t *)
retval: 1 - ok
retval: -1 - operand is hidden
def ev_out_segend(self, *args) ‑> int
Function to produce end of segment
ev_out_segend(self, outctx, seg) -> int
outctx (C++: outctx_t *)
seg (C++: segment_t *)
retval: 1 - ok
retval: 0 - not implemented
def ev_out_segstart(self, *args) ‑> int
Function to produce start of segment
ev_out_segstart(self, outctx, seg) -> int
outctx (C++: outctx_t *)
seg (C++: segment_t *)
retval: 1 - ok
retval: 0 - not implemented
def ev_out_special_item(self, *args) ‑> int
Generate text representation of an item in a special segment i.e. absolute symbols, externs, communal definitions etc
ev_out_special_item(self, outctx, segtype) -> int
outctx (C++: outctx_t *)
segtype (C++: uchar)
retval: 1 - ok
retval: 0 - not implemented
retval: -1 - overflow
def ev_realcvt(self, *args) ‑> int
Floating point -> IEEE conversion
ev_realcvt(self, m, e, swt) -> int
m: ptr to processor-specific floating point value (C++: void
*)
e: IDA representation of a floating point value (C++:
fpvalue_t *)
swt: operation (see realcvt() in ieee.h) (C++: uint16)
retval: 0 - not implemented
retval: 1 - ok
def ev_rename(self, *args) ‑> int
The kernel is going to rename a byte.
ev_rename(self, ea, new_name) -> int
ea (C++: ea_t)
new_name (C++: const char *)
retval: <0 - if the kernel should not rename it.
retval: 2 - to inhibit the notification. I.e., the kernel should not
rename, but ' set_name() ' should return 'true'. also see
\idpcode{renamed}
the return value is ignored when kernel is going to delete name
def ev_replaying_undo(self, *args) ‑> int
Replaying an undo/redo buffer
ev_replaying_undo(self, action_name, vec, is_undo) -> int
action_name: action that we perform undo/redo for. may be NULL
for intermediary buffers. (C++: const char *)
vec (C++: const undo_records_t *)
is_undo: true if performing undo, false if performing redo This
event may be generated multiple times per undo/redo (C++: bool)
def ev_set_code16_mode(self, *args) ‑> int
Some processors have ISA 16-bit mode e.g. ARM Thumb mode, PPC VLE, MIPS16 Set ISA 16-bit mode
ev_set_code16_mode(self, ea, code16) -> int
ea: address to set new ISA mode (C++: ea_t)
code16: true for 16-bit mode, false for 32-bit mode (C++:
bool)
def ev_set_idp_options(self, *args) ‑> int
Set IDP-specific configuration option Also see set_options_t in 'config.hpp'
ev_set_idp_options(self, keyword, value_type, value, idb_loaded) -> int
keyword (C++: const char *)
value_type (C++: int)
value (C++: const void *)
idb_loaded: true if the ev_oldfile/ev_newfile events have been
generated (C++: bool)
retval: 1 - ok
retval: 0 - not implemented
retval: -1 - error (and message in errbuf)
def ev_set_proc_options(self, *args) ‑> int
Called if the user specified an option string in the command line: -p<processor name>:<options>. Can be used for setting a processor subtype. Also called if option string is passed to 'set_processor_type()' and IDC's SetProcessorType().
ev_set_proc_options(self, options, confidence) -> int
options (C++: const char *)
confidence: 0: loader's suggestion 1: user's decision (C++:
int)
retval: <0 - if bad option string
def ev_setup_til(self, *args) ‑> int
Setup default type libraries. (called after loading a new file into the database). The processor module may load tils, setup memory model and perform other actions required to set up the type system. This is an optional callback.
def ev_shadow_args_size(self, *args) ‑> int
Get size of shadow args in bytes.
ev_shadow_args_size(self, shadow_args_size, pfn) -> int
shadow_args_size (C++: int *)
pfn: (may be NULL) (C++: func_t *)
retval: 1 - if filled *shadow_args_size
retval: 0 - not implemented
def ev_str2reg(self, *args) ‑> int
Convert a register name to a register number. The register number is the register index in the \ph{reg_names} array Most processor modules do not need to implement this callback It is useful only if
\ph{reg_names}
[reg] does not provide the correct register names
ev_str2reg(self, regname) -> int
regname (C++: const char *)
retval: register - number + 1
retval: 0 - not implemented or could not be decoded
def ev_term(self, *args) ‑> int
The IDP module is being unloaded.
def ev_treat_hindering_item(self, *args) ‑> int
An item hinders creation of another item.
ev_treat_hindering_item(self, hindering_item_ea, new_item_flags, new_item_ea, new_item_length) -> int
hindering_item_ea (C++: ea_t)
new_item_flags: (0 for code) (C++: flags_t)
new_item_ea (C++: ea_t)
new_item_length (C++: asize_t)
retval: 0 - no reaction
retval: !=0 - the kernel may delete the hindering item
def ev_undefine(self, *args) ‑> int
An item in the database (insn or data) is being deleted.
ev_undefine(self, ea) -> int
ea (C++: ea_t)
retval: 1 - do not delete srranges at the item end
retval: 0 - srranges can be deleted
def ev_update_call_stack(self, *args) ‑> int
Calculate the call stack trace for the given thread. This callback is invoked when the process is suspended and should fill the 'trace' object with the information about the current call stack. Note that this callback is NOT invoked if the current debugger backend implements stack tracing via debugger_t::event_t::ev_update_call_stack. The debugger-specific algorithm takes priority. Implementing this callback in the processor module is useful when multiple debugging platforms follow similar patterns, and thus the same processor-specific algorithm can be used for different platforms.
ev_update_call_stack(self, stack, tid, getreg, regvalues) -> int
stack: result (C++: call_stack_t *)
tid: thread id (C++: int)
getreg: function to get register values (C++:
processor_t::regval_getter_t *)
regvalues: register values array (C++: const regval_t *)
retval: 1 - ok
retval: -1 - failed
retval: 0 - unimplemented
def ev_use_arg_types(self, *args) ‑> int
Use information about callee arguments.
ev_use_arg_types(self, ea, fti, rargs) -> int
ea: address of the call instruction (C++: ea_t)
fti: info about function type (C++: func_type_data_t *)
rargs: array of register arguments (C++: funcargvec_t *)
retval: 1 - (and removes handled arguments from fti and rargs)
retval: 0 - not implemented
def ev_use_regarg_type(self, *args) ‑> PyObject *
Use information about register argument.
ev_use_regarg_type(self, ea, rargs) -> PyObject *
ea: address of the instruction (C++: ea_t)
rargs: vector of register arguments (including regs extracted
from scattered arguments) (C++: const funcargvec_t *)
retval: 1 -
retval: 0 - not implemented
def ev_use_stkarg_type(self, *args) ‑> int
Use information about a stack argument.
ev_use_stkarg_type(self, ea, arg) -> int
ea: address of the push instruction which pushes the function
argument into the stack (C++: ea_t)
arg: argument info (C++: const funcarg_t *)
retval: 1 - ok
retval: <=0 - failed, the kernel will create a comment with the
argument name or type for the instruction
def ev_validate_flirt_func(self, *args) ‑> int
Flirt has recognized a library function. This callback can be used by a plugin or proc module to intercept it and validate such a function.
ev_validate_flirt_func(self, start_ea, funcname) -> int
start_ea (C++: ea_t)
funcname (C++: const char *)
retval: -1 - do not create a function,
retval: 0 - function is validated
def ev_verify_noreturn(self, *args) ‑> int
The kernel wants to set 'noreturn' flags for a function.
ev_verify_noreturn(self, pfn) -> int
pfn (C++: func_t *)
retval: 0 - ok. any other value: do not set 'noreturn' flag
def ev_verify_sp(self, *args) ‑> int
All function instructions have been analyzed. Now the processor module can analyze the stack pointer for the whole function
ev_verify_sp(self, pfn) -> int
pfn (C++: func_t *)
retval: 0 - ok
retval: <0 - bad stack pointer
def hook(self, *args) ‑> bool
hook(self) -> bool
def unhook(self, *args) ‑> bool
unhook(self) -> bool
class asm_t (*args)
Proxy of C++ asm_t class.
__init__(self) -> asm_t

Instance variables

var a_align
asm_t_a_align_get(self) -> char const *
var a_ascii
asm_t_a_ascii_get(self) -> char const *
var a_band
asm_t_a_band_get(self) -> char const *
var a_bnot
asm_t_a_bnot_get(self) -> char const *
var a_bor
asm_t_a_bor_get(self) -> char const *
var a_bss
asm_t_a_bss_get(self) -> char const *
var a_byte
asm_t_a_byte_get(self) -> char const *
var a_comdef
asm_t_a_comdef_get(self) -> char const *
var a_curip
asm_t_a_curip_get(self) -> char const *
var a_double
asm_t_a_double_get(self) -> char const *
var a_dups
asm_t_a_dups_get(self) -> char const *
var a_dword
asm_t_a_dword_get(self) -> char const *
var a_equ
asm_t_a_equ_get(self) -> char const *
var a_extrn
asm_t_a_extrn_get(self) -> char const *
var a_float
asm_t_a_float_get(self) -> char const *
var a_include_fmt
asm_t_a_include_fmt_get(self) -> char const *
var a_mod
asm_t_a_mod_get(self) -> char const *
var a_oword
asm_t_a_oword_get(self) -> char const *
var a_packreal
asm_t_a_packreal_get(self) -> char const *
var a_public
asm_t_a_public_get(self) -> char const *
var a_qword
asm_t_a_qword_get(self) -> char const *
var a_rva
asm_t_a_rva_get(self) -> char const *
var a_seg
asm_t_a_seg_get(self) -> char const *
var a_shl
asm_t_a_shl_get(self) -> char const *
var a_shr
asm_t_a_shr_get(self) -> char const *
var a_sizeof_fmt
asm_t_a_sizeof_fmt_get(self) -> char const *
var a_tbyte
asm_t_a_tbyte_get(self) -> char const *
var a_vstruc_fmt
asm_t_a_vstruc_fmt_get(self) -> char const *
var a_weak
asm_t_a_weak_get(self) -> char const *
var a_word
asm_t_a_word_get(self) -> char const *
var a_xor
asm_t_a_xor_get(self) -> char const *
var a_yword
asm_t_a_yword_get(self) -> char const *
var accsep
asm_t_accsep_get(self) -> char
var ascsep
asm_t_ascsep_get(self) -> char
var cmnt
asm_t_cmnt_get(self) -> char const *
var cmnt2
asm_t_cmnt2_get(self) -> char const *
var end
asm_t_end_get(self) -> char const *
var esccodes
asm_t_esccodes_get(self) -> char const *
var flag
asm_t_flag_get(self) -> uint32
var flag2
asm_t_flag2_get(self) -> uint32
var header
asm_t_header_get(self) -> char const *const *
var help
asm_t_help_get(self) -> help_t
var high16
asm_t_high16_get(self) -> char const *
var high8
asm_t_high8_get(self) -> char const *
var lbrace
asm_t_lbrace_get(self) -> char
var low16
asm_t_low16_get(self) -> char const *
var low8
asm_t_low8_get(self) -> char const *
var name
asm_t_name_get(self) -> char const *
var origin
asm_t_origin_get(self) -> char const *
var rbrace
asm_t_rbrace_get(self) -> char
var uflag
asm_t_uflag_get(self) -> uint16
class processor_t
Proxy of C++ IDP_Hooks class.
__init__(self, _flags=0) -> IDP_Hooks
_flags: uint32

Ancestors

Methods

def auto_empty(self, *args)
def auto_empty_finally(self, *args)
def closebase(self, *args)
def compiler_changed(self, *args)
def deleting_func(self, pfn)
def determined_main(self, *args)
def func_added(self, pfn)
def get_auxpref(self, insn)
This function returns insn.auxpref value
def get_idpdesc(self)
This function must be present and should return the list of short processor names similar to the one in ph.psnames. This method can be overridden to return to the kernel a different IDP description.
def get_uFlag(self)
Use this utility function to retrieve the 'uFlag' global variable
def idasgn_loaded(self, *args)
def kernel_config_loaded(self, *args)
def make_code(self, *args)
def make_data(self, *args)
def renamed(self, *args)
def savebase(self, *args)
def segm_moved(self, from_ea, to_ea, size, changed_netmap)
def set_func_end(self, *args)
def set_func_start(self, *args)
def sgr_changed(self, *args)

Inherited members

class reg_access_t (*args)
Proxy of C++ reg_access_t class.
__init__(self) -> reg_access_t

Instance variables

var access_type
reg_access_t_access_type_get(self) -> access_type_t
var opnum
reg_access_t_opnum_get(self) -> uchar
var range
reg_access_t_range_get(self) -> bitrange_t
var regnum
reg_access_t_regnum_get(self) -> int

Methods

def have_common_bits(self, *args) ‑> bool
have_common_bits(self, r) -> bool
r (C++: const reg_access_t &)
class reg_access_vec_t (*args)
Proxy of C++ qvector< reg_access_t > class.
__init__(self) -> reg_access_vec_t
x: qvector< reg_access_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: reg_access_t const &
def at(self, *args) ‑> reg_access_t const &
at(self, _idx) -> reg_access_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< reg_access_t >::const_iterator
begin(self) -> reg_access_t
begin(self) -> reg_access_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< reg_access_t >::const_iterator
end(self) -> reg_access_t
end(self) -> reg_access_t
def erase(self, *args) ‑> qvector< reg_access_t >::iterator
erase(self, it) -> reg_access_t
it: qvector< reg_access_t >::iterator
erase(self, first, last) -> reg_access_t
first: qvector< reg_access_t >::iterator last: qvector< reg_access_t >::iterator
def extract(self, *args) ‑> reg_access_t *
extract(self) -> reg_access_t
def find(self, *args) ‑> qvector< reg_access_t >::const_iterator
find(self, x) -> reg_access_t
x: reg_access_t const &
find(self, x) -> reg_access_t
x: reg_access_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=reg_access_t())
x: reg_access_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: reg_access_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: reg_access_t * len: size_t
def insert(self, *args) ‑> qvector< reg_access_t >::iterator
insert(self, it, x) -> reg_access_t
it: qvector< reg_access_t >::iterator x: reg_access_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> reg_access_t &
push_back(self, x)
x: reg_access_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: reg_access_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< reg_access_t > &
def truncate(self, *args) ‑> void
truncate(self)
class reg_accesses_t (*args)
Proxy of C++ reg_accesses_t class.
__init__(self) -> reg_accesses_t

Ancestors

Inherited members

class reg_info_t (*args)
Proxy of C++ reg_info_t class.
__init__(self) -> reg_info_t

Instance variables

var reg
reg_info_t_reg_get(self) -> int
var size
reg_info_t_size_get(self) -> int

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: reg_info_t const &