|
| | __init__ (self, *args) |
| | init(self) -> mcallarg_t init(self, rarg) -> mcallarg_t
|
| |
| "void" | copy_mop (self, "mop_t" op) |
| | copy_mop(self, op)
|
| |
| "char const *" | dstr (self) |
| | dstr(self) -> char const *
|
| |
| "void" | set_regarg (self, *args) |
| | set_regarg(self, mr, sz, tif)
|
| |
| "void" | make_int (self, "int" val, "ea_t" val_ea, "int" opno=0) |
| | make_int(self, val, val_ea, opno=0)
|
| |
| "void" | make_uint (self, "int" val, "ea_t" val_ea, "int" opno=0) |
| | make_uint(self, val, val_ea, opno=0)
|
| |
| "void" | set_impptr_done (self) |
| | set_impptr_done(self)
|
| |
| "void" | set_udt (self) |
| | set_udt(self)
|
| |
| "void" | set_undef_val (self) |
| | set_undef_val(self)
|
| |
| "void" | set_lowaddr (self) |
| | set_lowaddr(self)
|
| |
| "bool" | is_impptr_done (self) |
| | is_impptr_done(self) -> bool
|
| |
| "bool" | is_udt (self) |
| | is_udt(self) -> bool
|
| |
| "bool" | probably_floating (self) |
| | probably_floating(self) -> bool
|
| |
| "bool" | is_undef_val (self) |
| | is_undef_val(self) -> bool
|
| |
| "bool" | is_lowaddr (self) |
| | is_lowaddr(self) -> bool
|
| |
| "bool" | is_ccflags (self) |
| | is_ccflags(self) -> bool
|
| |
| "bool" | is_pcval (self) |
| | is_pcval(self) -> bool
|
| |
| "bool" | is_glbaddr_from_fixup (self) |
| | is_glbaddr_from_fixup(self) -> bool
|
| |
| "mop_t &" | assign (self, "mop_t" rop) |
| | assign(self, rop) -> mop_t
|
| |
| "void" | zero (self) |
| | zero(self)
|
| |
| "void" | swap (self, "mop_t" rop) |
| | swap(self, rop)
|
| |
| "void" | erase (self) |
| | erase(self)
|
| |
| "void" | erase_but_keep_size (self) |
| | erase_but_keep_size(self)
|
| |
| "bool" | create_from_mlist (self, "mba_t" mba, "mlist_t" lst, "sval_t" fullsize) |
| | create_from_mlist(self, mba, lst, fullsize) -> bool Create operand from mlist_t.
|
| |
| "bool" | create_from_ivlset (self, "mba_t" mba, "ivlset_t" ivs, "sval_t" fullsize) |
| | create_from_ivlset(self, mba, ivs, fullsize) -> bool Create operand from ivlset_t.
|
| |
| "void" | create_from_vdloc (self, "mba_t" mba, "vdloc_t" loc, "int" _size) |
| | create_from_vdloc(self, mba, loc, _size) Create operand from vdloc_t.
|
| |
| "void" | create_from_scattered_vdloc (self, "mba_t" mba, "char const *" name, "tinfo_t" type, "vdloc_t" loc) |
| | create_from_scattered_vdloc(self, mba, name, type, loc) Create operand from scattered vdloc_t.
|
| |
| "void" | create_from_insn (self, "minsn_t" m) |
| | create_from_insn(self, m) Create operand from an instruction.
|
| |
| "void" | make_number (self, *args) |
| | make_number(self, _value, _size, _ea=BADADDR, opnum=0) Create an integer constant operand.
|
| |
| "bool" | make_fpnum (self, "void const *" bytes) |
| | make_fpnum(self, bytes) -> bool Create a floating point constant operand.
|
| |
| "void" | make_reg (self, *args) |
| | make_reg(self, reg)
|
| |
| "void" | make_gvar (self, "ea_t" ea) |
| | make_gvar(self, ea) Create a global variable operand.
|
| |
| "void" | make_stkvar (self, "mba_t" mba, "sval_t" off) |
| | make_stkvar(self, mba, off)
|
| |
| "void" | make_reg_pair (self, "int" loreg, "int" hireg, "int" halfsize) |
| | make_reg_pair(self, loreg, hireg, halfsize) Create pair of registers.
|
| |
| "void" | make_insn (self, "minsn_t" ins) |
| | make_insn(self, ins) Create a nested instruction.
|
| |
| "void" | make_blkref (self, "int" blknum) |
| | make_blkref(self, blknum) Create a global variable operand.
|
| |
| "void" | make_helper (self, "char const *" name) |
| | make_helper(self, name) Create a helper operand.
|
| |
| "bool" | empty (self) |
| | empty(self) -> bool
|
| |
| "bool" | is_reg (self, *args) |
| | is_reg(self) -> bool Is the specified register of the specified size? is_reg(self, _r) -> bool
|
| |
| "bool" | is_arglist (self) |
| | is_arglist(self) -> bool Is a list of arguments?
|
| |
| "bool" | is_cc (self) |
| | is_cc(self) -> bool Is a condition code?
|
| |
| "bool" | is_bit_reg (self, *args) |
| | is_bit_reg(self, reg) -> bool Is a bit register? This includes condition codes and eventually other bit registers
|
| |
| "bool" | is_kreg (self) |
| | is_kreg(self) -> bool Is a kernel register?
|
| |
| "bool" | is_mob (self, "int" serial) |
| | is_mob(self, serial) -> bool Is a block reference to the specified block?
|
| |
| "bool" | is_scattered (self) |
| | is_scattered(self) -> bool Is a scattered operand?
|
| |
| "bool" | is_glbaddr (self, *args) |
| | is_glbaddr(self) -> bool Is address of the specified global memory cell? is_glbaddr(self, ea) -> bool
|
| |
| "bool" | is_stkaddr (self) |
| | is_stkaddr(self) -> bool Is address of a stack variable?
|
| |
| "bool" | is_insn (self, *args) |
| | is_insn(self) -> bool Is a sub-instruction with the specified opcode? is_insn(self, code) -> bool
|
| |
| "bool" | has_side_effects (self, "bool" include_ldx_and_divs=False) |
| | has_side_effects(self, include_ldx_and_divs=False) -> bool Has any side effects?
|
| |
| "bool" | may_use_aliased_memory (self) |
| | may_use_aliased_memory(self) -> bool Is it possible for the operand to use aliased memory?
|
| |
| "bool" | is01 (self) |
| | is01(self) -> bool Are the possible values of the operand only 0 and 1? This function returns true for 0/1 constants, bit registers, the result of 'set' insns, etc.
|
| |
| "bool" | is_sign_extended_from (self, "int" nbytes) |
| | is_sign_extended_from(self, nbytes) -> bool Does the high part of the operand consist of the sign bytes?
|
| |
| "bool" | is_zero_extended_from (self, "int" nbytes) |
| | is_zero_extended_from(self, nbytes) -> bool Does the high part of the operand consist of zero bytes?
|
| |
| "bool" | is_extended_from (self, "int" nbytes, "bool" is_signed) |
| | is_extended_from(self, nbytes, is_signed) -> bool Does the high part of the operand consist of zero or sign bytes?
|
| |
| "bool" | equal_mops (self, "mop_t" rop, "int" eqflags) |
| | equal_mops(self, rop, eqflags) -> bool Compare operands.
|
| |
| "bool" | __eq__ (self, "mop_t" rop) |
| | eq(self, rop) -> bool
|
| |
| "bool" | __ne__ (self, "mop_t" rop) |
| | ne(self, rop) -> bool
|
| |
| "bool" | __lt__ (self, "mop_t" rop) |
| | lt(self, rop) -> bool
|
| |
| "int" | lexcompare (self, "mop_t" rop) |
| | lexcompare(self, rop) -> int
|
| |
| "int" | for_all_ops (self, "mop_visitor_t" mv, "tinfo_t" type=None, "bool" is_target=False) |
| | for_all_ops(self, mv, type=None, is_target=False) -> int Visit the operand and all its sub-operands.
|
| |
| "int" | for_all_scattered_submops (self, "scif_visitor_t" sv) |
| | for_all_scattered_submops(self, sv) -> int Visit all sub-operands of a scattered operand.
|
| |
| "uint64" | value (self, "bool" is_signed) |
| | value(self, is_signed) -> uint64 Retrieve value of a constant integer operand.
|
| |
| "int64" | signed_value (self) |
| | signed_value(self) -> int64
|
| |
| "uint64" | unsigned_value (self) |
| | unsigned_value(self) -> uint64
|
| |
| "void" | update_numop_value (self, "uint64" val) |
| | update_numop_value(self, val)
|
| |
| "bool" | is_constant (self, "bool" is_signed=True) |
| | is_constant(self, is_signed=True) -> bool Retrieve value of a constant integer operand.
|
| |
| "bool" | is_equal_to (self, "uint64" n, "bool" is_signed=True) |
| | is_equal_to(self, n, is_signed=True) -> bool
|
| |
| "bool" | is_zero (self) |
| | is_zero(self) -> bool
|
| |
| "bool" | is_one (self) |
| | is_one(self) -> bool
|
| |
| "bool" | is_positive_constant (self) |
| | is_positive_constant(self) -> bool
|
| |
| "bool" | is_negative_constant (self) |
| | is_negative_constant(self) -> bool
|
| |
| "ssize_t" | get_stkvar (self, "udm_t" udm=None, "uval_t *" p_idaoff=None) |
| | get_stkvar(self, udm=None, p_idaoff=None) -> ssize_t Retrieve the referenced stack variable.
|
| |
| "bool" | get_stkoff (self, "sval_t *" p_vdoff) |
| | get_stkoff(self, p_vdoff) -> bool Get the referenced stack offset.
|
| |
| "minsn_t *" | get_insn (self, *args) |
| | get_insn(self, code) -> minsn_t
|
| |
| "bool" | make_low_half (self, "int" width) |
| | make_low_half(self, width) -> bool Make the low part of the operand.
|
| |
| "bool" | make_high_half (self, "int" width) |
| | make_high_half(self, width) -> bool Make the high part of the operand.
|
| |
| "bool" | make_first_half (self, "int" width) |
| | make_first_half(self, width) -> bool Make the first part of the operand.
|
| |
| "bool" | make_second_half (self, "int" width) |
| | make_second_half(self, width) -> bool Make the second part of the operand.
|
| |
| "bool" | shift_mop (self, "int" offset) |
| | shift_mop(self, offset) -> bool Shift the operand.
|
| |
| "bool" | change_size (self, "int" nsize, "side_effect_t" sideff=WITH_SIDEFF) |
| | change_size(self, nsize, sideff=WITH_SIDEFF) -> bool Change the operand size.
|
| |
| "bool" | double_size (self, "side_effect_t" sideff=WITH_SIDEFF) |
| | double_size(self, sideff=WITH_SIDEFF) -> bool
|
| |
| "bool" | preserve_side_effects (self, "mblock_t" blk, "minsn_t" top, "bool *" moved_calls=None) |
| | preserve_side_effects(self, blk, top, moved_calls=None) -> bool Move subinstructions with side effects out of the operand.
|
| |
| "void" | apply_ld_mcode (self, "mcode_t" mcode, "ea_t" ea, "int" newsize) |
| | apply_ld_mcode(self, mcode, ea, newsize) Apply a unary opcode to the operand.
|
| |
| "void" | apply_xdu (self, "ea_t" ea, "int" newsize) |
| | apply_xdu(self, ea, newsize)
|
| |
| "void" | apply_xds (self, "ea_t" ea, "int" newsize) |
| | apply_xds(self, ea, newsize)
|
| |
| | replace_by (self, o) |
| |
|
| "void" | _print (self, *args) |
| | _print(self, shins_flags=0x04|0x02)
|
| |
| "void" | _make_reg (self, *args) |
| | _make_reg(self, reg)
|
| |
| "void" | _make_lvar (self, "mba_t" mba, "int" idx, "sval_t" off=0) |
| | _make_lvar(self, mba, idx, off=0)
|
| |
| "void" | _make_gvar (self, "ea_t" ea) |
| | _make_gvar(self, ea)
|
| |
| "void" | _make_stkvar (self, "mba_t" mba, "sval_t" off) |
| | _make_stkvar(self, mba, off)
|
| |
| "void" | _make_insn (self, "minsn_t" ins) |
| | _make_insn(self, ins)
|
| |
| "void" | _make_blkref (self, "int" blknum) |
| | _make_blkref(self, blknum)
|
| |
| "void" | _make_strlit (self, "char const *" str) |
| | _make_strlit(self, str)
|
| |
| "void" | _make_callinfo (self, "mcallinfo_t" fi) |
| | _make_callinfo(self, fi)
|
| |
| "void" | _make_cases (self, "mcases_t" _cases) |
| | _make_cases(self, _cases)
|
| |
| "void" | _make_pair (self, "mop_pair_t" _pair) |
| | _make_pair(self, _pair)
|
| |
| "void" | _register (self) |
| | _register(self)
|
| |
| "void" | _deregister (self) |
| | _deregister(self)
|
| |
| "mopt_t" | _get_t (self) |
| | _get_t(self) -> mopt_t
|
| |
| "void" | _set_t (self, "mopt_t" v) |
| | _set_t(self, v)
|
| |
| | _ensure_no_t (self) |
| |
| "PyObject *" | _obj_id (self) |
| | _obj_id(self) -> PyObject *
|
| |
| | _ensure_cond (self, ok, cond_str) |
| |
| | _ensure_no_obj (self, o, attr, attr_is_acquired) |
| |
| | _ensure_ownership_transferrable (self, v) |
| |
| | _acquire_ownership (self, v, acquire) |
| |
| | _maybe_disown_and_deregister (self) |
| |
| | _own_and_register (self) |
| |
| | _meminfo (self) |
| |
| "mnumber_t *" | _get_nnn (self) |
| | _get_nnn(self) -> mnumber_t
|
| |
| "void" | _set_nnn (self, "mnumber_t" _v) |
| | _set_nnn(self, _v)
|
| |
| "minsn_t *" | _get_d (self) |
| | _get_d(self) -> minsn_t
|
| |
| "void" | _set_d (self, "minsn_t" _v) |
| | _set_d(self, _v)
|
| |
| "stkvar_ref_t *" | _get_s (self) |
| | _get_s(self) -> stkvar_ref_t
|
| |
| "void" | _set_s (self, "stkvar_ref_t" _v) |
| | _set_s(self, _v)
|
| |
| "mcallinfo_t *" | _get_f (self) |
| | _get_f(self) -> mcallinfo_t
|
| |
| "void" | _set_f (self, "mcallinfo_t" _v) |
| | _set_f(self, _v)
|
| |
| "lvar_ref_t *" | _get_l (self) |
| | _get_l(self) -> lvar_ref_t
|
| |
| "void" | _set_l (self, "lvar_ref_t" _v) |
| | _set_l(self, _v)
|
| |
| "mop_addr_t *" | _get_a (self) |
| | _get_a(self) -> mop_addr_t
|
| |
| "void" | _set_a (self, "mop_addr_t" _v) |
| | _set_a(self, _v)
|
| |
| "mcases_t *" | _get_c (self) |
| | _get_c(self) -> mcases_t
|
| |
| "void" | _set_c (self, "mcases_t" _v) |
| | _set_c(self, _v)
|
| |
| "fnumber_t *" | _get_fpc (self) |
| | _get_fpc(self) -> fnumber_t
|
| |
| "void" | _set_fpc (self, "fnumber_t" _v) |
| | _set_fpc(self, _v)
|
| |
| "mop_pair_t *" | _get_pair (self) |
| | _get_pair(self) -> mop_pair_t
|
| |
| "void" | _set_pair (self, "mop_pair_t" _v) |
| | _set_pair(self, _v)
|
| |
| "scif_t *" | _get_scif (self) |
| | _get_scif(self) -> scif_t
|
| |
| "void" | _set_scif (self, "scif_t" _v) |
| | _set_scif(self, _v)
|
| |
| "mreg_t" | _get_r (self) |
| | _get_r(self) -> mreg_t
|
| |
| "void" | _set_r (self, "mreg_t" _v) |
| | _set_r(self, _v)
|
| |
| "ea_t" | _get_g (self) |
| | _get_g(self) -> ea_t
|
| |
| "void" | _set_g (self, "ea_t" _v) |
| | _set_g(self, _v)
|
| |
| "int" | _get_b (self) |
| | _get_b(self) -> int
|
| |
| "void" | _set_b (self, "int" _v) |
| | _set_b(self, _v)
|
| |
| "char const *" | _get_cstr (self) |
| | _get_cstr(self) -> char const *
|
| |
| "void" | _set_cstr (self, "char const *" _v) |
| | _set_cstr(self, _v)
|
| |
| "char const *" | _get_helper (self) |
| | _get_helper(self) -> char const *
|
| |
| "void" | _set_helper (self, "char const *" _v) |
| | _set_helper(self, _v)
|
| |
Public Member Functions inherited from mop_t
1.12.0