Module index

Module ida_idd

IDA Plugin SDK API wrapper: idd

Global variables

var BBLK_TRACE
BBLK_TRACE = 8
var BPT_DEFAULT
BPT_DEFAULT = 12
var BPT_EXEC
BPT_EXEC = 8
var BPT_RDWR
BPT_RDWR = 3
var BPT_READ
BPT_READ = 2
var BPT_SOFT
BPT_SOFT = 4
var BPT_WRITE
BPT_WRITE = 1
var BREAKPOINT
BREAKPOINT = 16
var DEF_ADDRSIZE
DEF_ADDRSIZE = 4
var DRC_CRC
DRC_CRC = 2
var DRC_ERROR
DRC_ERROR = -7
var DRC_EVENTS
DRC_EVENTS = 3
var DRC_FAILED
DRC_FAILED = -1
var DRC_IDBSEG
DRC_IDBSEG = -4
var DRC_NETERR
DRC_NETERR = -2
var DRC_NOCHG
DRC_NOCHG = -6
var DRC_NOFILE
DRC_NOFILE = -3
var DRC_NONE
DRC_NONE = 0
var DRC_NOPROC
DRC_NOPROC = -5
var DRC_OK
DRC_OK = 1
var EXCEPTION
EXCEPTION = 64
var EXC_BREAK
break on the exception
var EXC_HANDLE
should be handled by the debugger?
var EXC_MSG
instead of a warning, log the exception to the output window
var EXC_SILENT
do not warn or log to the output window
var FUNC_TRACE
FUNC_TRACE = 4
var IDD_INTERFACE_VERSION
The IDD interface version number.
var INFORMATION
INFORMATION = 512
var INSN_TRACE
INSN_TRACE = 2
var LIB_LOADED
LIB_LOADED = 128
var LIB_UNLOADED
LIB_UNLOADED = 256
var NO_EVENT
NO_EVENT = 0
var NO_PROCESS
No process.
var NO_THREAD
No thread. in 'PROCESS_STARTED' this value can be used to specify that the main thread has not been created. It will be initialized later by a 'THREAD_STARTED' event.
var PROCESS_ATTACHED
PROCESS_ATTACHED = 1024
var PROCESS_DETACHED
PROCESS_DETACHED = 2048
var PROCESS_EXITED
PROCESS_EXITED = 2
var PROCESS_STARTED
PROCESS_STARTED = 1
var PROCESS_SUSPENDED
PROCESS_SUSPENDED = 4096
var REGISTER_ADDRESS
may contain an address
var REGISTER_CS
code segment
var REGISTER_CUSTFMT
register should be displayed using a custom data format. the format name is in bit_strings[0] the corresponding 'regval_t' will use 'bytevec_t'
var REGISTER_FP
frame pointer
var REGISTER_IP
instruction pointer
var REGISTER_NOLF
displays this register without returning to the next line allowing the next register to be displayed to its right (on the same line)
var REGISTER_READONLY
the user can't modify the current value of this register
var REGISTER_SP
stack pointer
var REGISTER_SS
stack segment
var RESMOD_HANDLE
RESMOD_HANDLE = 8
var RESMOD_INTO
RESMOD_INTO = 1
var RESMOD_MAX
RESMOD_MAX = 9
var RESMOD_NONE
RESMOD_NONE = 0
var RESMOD_OUT
RESMOD_OUT = 3
var RESMOD_OVER
RESMOD_OVER = 2
var RESMOD_SRCINTO
RESMOD_SRCINTO = 4
var RESMOD_SRCOUT
RESMOD_SRCOUT = 6
var RESMOD_SRCOVER
RESMOD_SRCOVER = 5
var RESMOD_USER
RESMOD_USER = 7
var RQ_IDAIDLE
RQ_IDAIDLE = 128
var RQ_IGNWERR
RQ_IGNWERR = 4
var RQ_MASKING
RQ_MASKING = 1
var RQ_NOSUSP
RQ_NOSUSP = 0
var RQ_PROCEXIT
RQ_PROCEXIT = 64
var RQ_RESMOD
RQ_RESMOD = 61440
var RQ_RESMOD_SHIFT
RQ_RESMOD_SHIFT = 12
var RQ_RESUME
RQ_RESUME = 512
var RQ_SILENT
RQ_SILENT = 8
var RQ_SUSPEND
RQ_SUSPEND = 2
var RQ_SUSPRUN
RQ_SUSPRUN = 256
var RQ_SWSCREEN
RQ_SWSCREEN = 16
var RQ_VERBOSE
RQ_VERBOSE = 0
var RQ__NOTHRRF
RQ__NOTHRRF = 32
var RVT_FLOAT
floating point
var RVT_INT
integer
var RVT_UNAVAILABLE
unavailable other values mean custom data type
var STEP
STEP = 32
var STEP_TRACE
STEP_TRACE = 1
var THREAD_EXITED
THREAD_EXITED = 8
var THREAD_STARTED
THREAD_STARTED = 4
var TRACE_FULL
TRACE_FULL = 8192

Functions

def appcall(*args) ‑> PyObject *
appcall(func_ea, tid, _type_or_none, _fields, arg_list) -> PyObject *
func_ea: ea_t tid: thid_t _type_or_none: bytevec_t const & _fields: bytevec_t const & arg_list: PyObject *
def can_exc_continue(*args) ‑> bool
can_exc_continue(ev) -> bool
ev: debug_event_t const *
def cleanup_appcall(*args) ‑> error_t
Cleanup after manual appcall.
cleanup_appcall(tid) -> error_t
tid: thread to use. NO_THREAD means to use the current thread
The application state is restored as it was before calling the last appcall(). Nested appcalls are supported. (C++: thid_t)
return: eOk if successful, otherwise an error code
def dbg_appcall(*args) ‑> error_t
Call a function from the debugged application.
dbg_appcall(retval, func_ea, tid, ptif, argv, argnum) -> error_t
retval (C++: idc_value_t *)
func_ea: address to call (C++: ea_t)
tid: thread to use. NO_THREAD means to use the current thread
(C++: thid_t)
ptif: pointer to type of the function to call (C++: const
tinfo_t *)
argv: array of arguments (C++: idc_value_t *)
argnum: number of actual arguments (C++: size_t)
return: eOk if successful, otherwise an error code
def dbg_get_memory_info(*args) ‑> PyObject *
dbg_get_memory_info() -> PyObject *
This function returns the memory configuration of a debugged process.
return:
None if no debugger is active
tuple(start_ea, end_ea, name, sclass, sbase, bitness, perm)
def dbg_get_name(*args) ‑> PyObject *
dbg_get_name() -> PyObject *
This function returns the current debugger's name.
return: Debugger name or None if no debugger is active
def dbg_get_registers(*args) ‑> PyObject *
dbg_get_registers() -> PyObject *
This function returns the register definition from the currently loaded debugger. Basically, it returns an array of structure similar to to idd.hpp / register_info_t
return:
None if no debugger is loaded
tuple(name, flags, class, dtype, bit_strings, default_bit_strings_mask)
The bit_strings can be a tuple of strings or None (if the register does not have bit_strings)
def dbg_get_thread_sreg_base(*args) ‑> PyObject *
dbg_get_thread_sreg_base(tid, sreg_value) -> PyObject *
Returns the segment register base value
tid: thread id
sreg_value: segment register (selector) value
return:
  • The base as an 'ea'
  • Or None on failure
def dbg_read_memory(*args) ‑> PyObject *
dbg_read_memory(ea, sz) -> PyObject *
Reads from the debugee's memory at the specified ea
return:
  • The read buffer (as a string)
  • Or None on failure
def dbg_write_memory(*args) ‑> PyObject *
dbg_write_memory(ea, buf) -> PyObject *
Writes a buffer to the debugee's memory
return: Boolean
def get_event_bpt_hea(*args) ‑> ea_t
get_event_bpt_hea(ev) -> ea_t
ev: debug_event_t const *
def get_event_exc_code(*args) ‑> uint
get_event_exc_code(ev) -> uint
ev: debug_event_t const *
def get_event_exc_ea(*args) ‑> ea_t
get_event_exc_ea(ev) -> ea_t
ev: debug_event_t const *
def get_event_exc_info(*args) ‑> size_t
get_event_exc_info(ev) -> str
ev: debug_event_t const *
def get_event_info(*args) ‑> size_t
get_event_info(ev) -> str
ev: debug_event_t const *
def get_event_module_base(*args) ‑> ea_t
get_event_module_base(ev) -> ea_t
ev: debug_event_t const *
def get_event_module_name(*args) ‑> size_t
get_event_module_name(ev) -> str
ev: debug_event_t const *
def get_event_module_size(*args) ‑> asize_t
get_event_module_size(ev) -> asize_t
ev: debug_event_t const *
def set_debug_event_code(*args) ‑> void
set_debug_event_code(ev, id)
ev (C++: debug_event_t *)
id (C++: event_id_t)

Classes

class Appcall__

Class variables

var APPCALL_DEBEV
Return debug event information If this bit is set, exceptions during appcall will generate idc exceptions with full information about the exception
var APPCALL_MANUAL
Only set up the appcall, do not run it. you should call CleanupAppcall() when finished
var APPCALL_TIMEOUT
Appcall with timeout The timeout value in milliseconds is specified in the high 2 bytes of the 'options' argument: If timed out, errbuf will contain "timeout".

Static methods

def UTF16(s)
def array(type_name)
Defines an array type. Later you need to pack() / unpack()
def buffer(str=None, size=0, fill='\x00')
Creates a string buffer. The returned value (r) will be a byref object. Use r.value to get the contents and r.size to get the buffer's size
def byref(val)
Method to create references to immutable objects Currently we support references to int/strings Objects need not be passed by reference (this will be done automatically)
def cleanup_appcall(tid=0)
Equivalent to IDC's CleanupAppcall()
def cstr(val)
def get_appcall_options()
Return the global Appcall options
def int64(v)
Whenever a 64bit number is needed use this method to construct an object
def obj(**kwds)
Returns an empty object or objects with attributes as passed via its keywords arguments
def proto(name_or_ea, proto_or_tinfo, flags=None)
Allows you to instantiate an appcall (callable object) with the desired prototype
name_or_ea: The name of the function (will be resolved with LocByName())
proto_or_tinfo: function prototype as a string or type of the function as tinfo_t object
return:
  • On failure it raises an exception if the prototype could not be parsed
    or the address is not resolvable
  • Returns a callbable Appcall instance with the given prototypes and flags
def set_appcall_options(opt)
Method to change the Appcall options globally (not per Appcall)
def typedobj(typedecl_or_tinfo, ea=None)
Returns an appcall object for a type (can be given as tinfo_t object or as a string declaration) One can then use retrieve() member method
ea: Optional parameter that later can be used to retrieve the type
return: Appcall object or raises ValueError exception
def unicode(s)
def valueof(name, default=0)
Returns the numeric value of a given name string. If the name could not be resolved then the default value will be returned

Instance variables

var Consts
Use Appcall.Consts.CONST_NAME to access constants
class Appcall_array__ (tp)
This class is used with Appcall.array() method

Methods

def pack(self, L)
Packs a list or tuple into a byref buffer
def try_to_convert_to_list(self, obj)
Is this object a list? We check for the existance of attribute zero and attribute self.size-1
def unpack(self, buf, as_list=True)
Unpacks an array back into a list or an object
class Appcall_callable__ (ea, tinfo_or_typestr=None, fields=None)
Helper class to issue appcalls using a natural syntax:
appcall.FunctionNameInTheDatabase(arguments, ....)
or
appcall["Function@8"](arguments, ...)
or
f8 = appcall["Function@8"] f8(arg1, arg2, ...)
or
o = appcall.obj() i = byref(5) appcall.funcname(arg1, i, "hello", o)
Initializes an appcall with a given function ea

Instance variables

var ea
Returns or sets the EA associated with this object
var fields
Returns the field names
var options
Sets the Appcall options locally to this Appcall instance
var size
Returns the size of the type
var tif
Returns the tinfo_t object
var timeout
An Appcall instance can change its timeout value with this attribute
var type
Returns the typestring

Methods

def retrieve(self, src=None, flags=0)
Unpacks a typed object from the database if an ea is given or from a string if a string was passed
src: the address of the object or a string
return: Returns a tuple of boolean and object or error number (Bool, Error | Object).
def store(self, obj, dest_ea=None, base_ea=0, flags=0)
Packs an object into a given ea if provided or into a string if no address was passed.
obj: The object to pack
dest_ea: If packing to idb this will be the store location
base_ea: If packing to a buffer, this will be the base that will be used to relocate the pointers
return:
  • If packing to a string then a Tuple(Boolean, packed_string or error code)
  • If packing to the database then a return code is returned (0 is success)
class Appcall_consts__ (default=None)
Helper class used by Appcall.Consts attribute It is used to retrieve constants via attribute access
class bptaddr_t (*args)
Proxy of C++ bptaddr_t class.
__init__(self) -> bptaddr_t

Instance variables

var hea
bptaddr_t_hea_get(self) -> ea_t
var kea
bptaddr_t_kea_get(self) -> ea_t
class call_stack_info_t (*args)
Proxy of C++ call_stack_info_t class.
__init__(self) -> call_stack_info_t

Instance variables

var callea
call_stack_info_t_callea_get(self) -> ea_t
var fp
call_stack_info_t_fp_get(self) -> ea_t
var funcea
call_stack_info_t_funcea_get(self) -> ea_t
var funcok
call_stack_info_t_funcok_get(self) -> bool
class call_stack_info_vec_t (*args)
Proxy of C++ qvector< call_stack_info_t > class.
__init__(self) -> call_stack_info_vec_t
x: qvector< call_stack_info_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: call_stack_info_t const &
def at(self, *args) ‑> call_stack_info_t const &
at(self, _idx) -> call_stack_info_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< call_stack_info_t >::const_iterator
begin(self) -> call_stack_info_t
begin(self) -> call_stack_info_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< call_stack_info_t >::const_iterator
end(self) -> call_stack_info_t
end(self) -> call_stack_info_t
def erase(self, *args) ‑> qvector< call_stack_info_t >::iterator
erase(self, it) -> call_stack_info_t
it: qvector< call_stack_info_t >::iterator
erase(self, first, last) -> call_stack_info_t
first: qvector< call_stack_info_t >::iterator last: qvector< call_stack_info_t >::iterator
def extract(self, *args) ‑> call_stack_info_t *
extract(self) -> call_stack_info_t
def find(self, *args) ‑> qvector< call_stack_info_t >::const_iterator
find(self, x) -> call_stack_info_t
x: call_stack_info_t const &
find(self, x) -> call_stack_info_t
x: call_stack_info_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=call_stack_info_t())
x: call_stack_info_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: call_stack_info_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: call_stack_info_t * len: size_t
def insert(self, *args) ‑> qvector< call_stack_info_t >::iterator
insert(self, it, x) -> call_stack_info_t
it: qvector< call_stack_info_t >::iterator x: call_stack_info_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> call_stack_info_t &
push_back(self, x)
x: call_stack_info_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: call_stack_info_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< call_stack_info_t > &
def truncate(self, *args) ‑> void
truncate(self)
class call_stack_t (*args)
Proxy of C++ call_stack_t class.
__init__(self) -> call_stack_t

Ancestors

Inherited members

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

Instance variables

var addrsize
debapp_attrs_t_addrsize_get(self) -> int
var cbsize
debapp_attrs_t_cbsize_get(self) -> int32
var is_be
debapp_attrs_t_is_be_get(self) -> int
var platform
debapp_attrs_t_platform_get(self) -> qstring *
class debug_event_t (*args)
Proxy of C++ debug_event_t class.
__init__(self) -> debug_event_t
r: debug_event_t const &

Instance variables

var ea
debug_event_t_ea_get(self) -> ea_t
var handled
debug_event_t_handled_get(self) -> bool
var pid
debug_event_t_pid_get(self) -> pid_t
var tid
debug_event_t_tid_get(self) -> thid_t

Methods

def bpt(self, *args) ‑> bptaddr_t const &
'EXCEPTION'
def bpt_ea(self, *args) ‑> ea_t
On some systems with special memory mappings the triggered ea might be different from the actual ea. Calculate the address to use.
def clear(self, *args) ‑> void
clear the dependent information (see below), set event code to NO_EVENT
def clear_all(self, *args) ‑> void
clear_all(self)
def copy(self, *args) ‑> debug_event_t &
copy(self, r) -> debug_event_t
r (C++: const debug_event_t &)
def eid(self, *args) ‑> event_id_t
Event code.
def exc(self, *args) ‑> excinfo_t const &
exc(self) -> excinfo_t
exc(self) -> excinfo_t
def exit_code(self, *args) ‑> int const &
'THREAD_STARTED' (thread name) 'LIB_UNLOADED' (unloaded library name) 'INFORMATION' (will be displayed in the output window if not empty)
def info(self, *args) ‑> qstring const &
'BREAKPOINT'
def modinfo(self, *args) ‑> modinfo_t const &
Information that depends on the event code:
< 'PROCESS_STARTED' , 'PROCESS_ATTACHED' , 'LIB_LOADED' 'PROCESS_EXITED' , 'THREAD_EXITED'
def set_bpt(self, *args) ‑> bptaddr_t &
set_bpt(self) -> bptaddr_t
def set_eid(self, *args) ‑> void
Set event code. If the new event code is compatible with the old one then the dependent information (see below) will be preserved. Otherwise the event will be cleared and the new event code will be set.
set_eid(self, id)
id (C++: event_id_t)
def set_exception(self, *args) ‑> excinfo_t &
set_exception(self) -> excinfo_t
def set_exit_code(self, *args) ‑> void
set_exit_code(self, id, code)
id (C++: event_id_t)
code (C++: int)
def set_info(self, *args) ‑> qstring &
set_info(self, id) -> qstring &
id (C++: event_id_t)
def set_modinfo(self, *args) ‑> modinfo_t &
set_modinfo(self, id) -> modinfo_t
id (C++: event_id_t)
class exception_info_t (*args)
Proxy of C++ exception_info_t class.
__init__(self) -> exception_info_t
_code: uint _flags: uint32 _name: char const * _desc: char const *

Instance variables

var code
exception_info_t_code_get(self) -> uint
var desc
exception_info_t_desc_get(self) -> qstring *
var flags
exception_info_t_flags_get(self) -> uint32
var name
exception_info_t_name_get(self) -> qstring *

Methods

def break_on(self, *args) ‑> bool
Should we break on the exception?
def handle(self, *args) ‑> bool
Should we handle the exception?
class excinfo_t (*args)
Proxy of C++ excinfo_t class.
__init__(self) -> excinfo_t

Instance variables

var can_cont
excinfo_t_can_cont_get(self) -> bool
var code
excinfo_t_code_get(self) -> uint32
var ea
excinfo_t_ea_get(self) -> ea_t
var info
excinfo_t_info_get(self) -> qstring *
class excvec_t (*args)
Proxy of C++ qvector< exception_info_t > class.
__init__(self) -> excvec_t
x: qvector< exception_info_t > const &

Methods

def at(self, *args) ‑> exception_info_t const &
at(self, _idx) -> exception_info_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< exception_info_t >::const_iterator
begin(self) -> exception_info_t
begin(self) -> exception_info_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< exception_info_t >::const_iterator
end(self) -> exception_info_t
end(self) -> exception_info_t
def erase(self, *args) ‑> qvector< exception_info_t >::iterator
erase(self, it) -> exception_info_t
it: qvector< exception_info_t >::iterator
erase(self, first, last) -> exception_info_t
first: qvector< exception_info_t >::iterator last: qvector< exception_info_t >::iterator
def extract(self, *args) ‑> exception_info_t *
extract(self) -> exception_info_t
def front(self)
def grow(self, *args) ‑> void
grow(self, x=exception_info_t())
x: exception_info_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: exception_info_t * len: size_t
def insert(self, *args) ‑> qvector< exception_info_t >::iterator
insert(self, it, x) -> exception_info_t
it: qvector< exception_info_t >::iterator x: exception_info_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> exception_info_t &
push_back(self, x)
x: exception_info_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: exception_info_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< exception_info_t > &
def truncate(self, *args) ‑> void
truncate(self)
class meminfo_vec_t (*args)
Proxy of C++ qvector< memory_info_t > class.
__init__(self) -> meminfo_vec_t
x: qvector< memory_info_t > const &

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: memory_info_t const &
def at(self, *args) ‑> memory_info_t const &
at(self, _idx) -> memory_info_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< memory_info_t >::const_iterator
begin(self) -> memory_info_t
begin(self) -> memory_info_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< memory_info_t >::const_iterator
end(self) -> memory_info_t
end(self) -> memory_info_t
def erase(self, *args) ‑> qvector< memory_info_t >::iterator
erase(self, it) -> memory_info_t
it: qvector< memory_info_t >::iterator
erase(self, first, last) -> memory_info_t
first: qvector< memory_info_t >::iterator last: qvector< memory_info_t >::iterator
def extract(self, *args) ‑> memory_info_t *
extract(self) -> memory_info_t
def find(self, *args) ‑> qvector< memory_info_t >::const_iterator
find(self, x) -> memory_info_t
x: memory_info_t const &
find(self, x) -> memory_info_t
x: memory_info_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=memory_info_t())
x: memory_info_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: memory_info_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: memory_info_t * len: size_t
def insert(self, *args) ‑> qvector< memory_info_t >::iterator
insert(self, it, x) -> memory_info_t
it: qvector< memory_info_t >::iterator x: memory_info_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> memory_info_t &
push_back(self, x)
x: memory_info_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: memory_info_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< memory_info_t > &
def truncate(self, *args) ‑> void
truncate(self)
class memory_info_t (*args)
Proxy of C++ memory_info_t class.
__init__(self) -> memory_info_t

Ancestors

Instance variables

var bitness
memory_info_t_bitness_get(self) -> uchar
var name
memory_info_t_name_get(self) -> qstring *
var perm
memory_info_t_perm_get(self) -> uchar
var sbase
memory_info_t_sbase_get(self) -> ea_t
var sclass
memory_info_t_sclass_get(self) -> qstring *

Inherited members

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

Instance variables

var base
modinfo_t_base_get(self) -> ea_t
var name
modinfo_t_name_get(self) -> qstring *
var rebase_to
modinfo_t_rebase_to_get(self) -> ea_t
var size
modinfo_t_size_get(self) -> asize_t
class process_info_t (*args)
Proxy of C++ process_info_t class.
__init__(self) -> process_info_t

Instance variables

var name
process_info_t_name_get(self) -> qstring *
var pid
process_info_t_pid_get(self) -> pid_t
class procinfo_vec_t (*args)
Proxy of C++ qvector< process_info_t > class.
__init__(self) -> procinfo_vec_t
x: qvector< process_info_t > const &

Methods

def at(self, *args) ‑> process_info_t const &
at(self, _idx) -> process_info_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< process_info_t >::const_iterator
begin(self) -> process_info_t
begin(self) -> process_info_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< process_info_t >::const_iterator
end(self) -> process_info_t
end(self) -> process_info_t
def erase(self, *args) ‑> qvector< process_info_t >::iterator
erase(self, it) -> process_info_t
it: qvector< process_info_t >::iterator
erase(self, first, last) -> process_info_t
first: qvector< process_info_t >::iterator last: qvector< process_info_t >::iterator
def extract(self, *args) ‑> process_info_t *
extract(self) -> process_info_t
def front(self)
def grow(self, *args) ‑> void
grow(self, x=process_info_t())
x: process_info_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: process_info_t * len: size_t
def insert(self, *args) ‑> qvector< process_info_t >::iterator
insert(self, it, x) -> process_info_t
it: qvector< process_info_t >::iterator x: process_info_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> process_info_t &
push_back(self, x)
x: process_info_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: process_info_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< process_info_t > &
def truncate(self, *args) ‑> void
truncate(self)
class register_info_t (*args)
Proxy of C++ register_info_t class.
__init__(self) -> register_info_t

Instance variables

var bit_strings
register_info_t_bit_strings_get(self) -> char const *const *
var default_bit_strings_mask
register_info_t_default_bit_strings_mask_get(self) -> uval_t
var dtype
register_info_t_dtype_get(self) -> op_dtype_t
var flags
register_info_t_flags_get(self) -> uint32
var name
register_info_t_name_get(self) -> char const *
var register_class
register_info_t_register_class_get(self) -> register_class_t
class regval_t (*args)
Proxy of C++ regval_t class.
__init__(self) -> regval_t
r: regval_t const &

Instance variables

var fval
regval_t_fval_get(self) -> fpvalue_t
var ival
regval_t_ival_get(self) -> uint64
var rvtype
regval_t_rvtype_get(self) -> int32

Methods

def bytes(self, *args) ‑> bytevec_t const &
bytes(self) -> bytevec_t
bytes(self) -> bytevec_t const &
def clear(self, *args) ‑> void
Clear register value.
def get_data(self, *args) ‑> void const *
get_data(self)
get_data(self) -> void const *
def get_data_size(self, *args) ‑> size_t
get_data_size(self) -> size_t
def set_bytes(self, *args) ‑> bytevec_t &
set_bytes(self, data, size)
data: uchar const * size: size_t
set_bytes(self, v)
v: bytevec_t const &
def set_float(self, *args) ‑> void
set_float(self, x)
x: fpvalue_t const &
def set_int(self, *args) ‑> void
set_int(self, x)
x: uint64
def set_unavailable(self, *args) ‑> void
set_unavailable(self)
def swap(self, *args) ‑> void
Set this = r and r = this.
swap(self, r)
r (C++: regval_t &)
class scattered_segm_t (*args)
Proxy of C++ scattered_segm_t class.
__init__(self) -> scattered_segm_t

Ancestors

Instance variables

var name
scattered_segm_t_name_get(self) -> qstring *

Inherited members

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

Instance variables

var name
thread_name_t_name_get(self) -> qstring *
var tid
thread_name_t_tid_get(self) -> thid_t