miasm.arch.arm.sem Namespace Reference

Classes
class	arminfo
class	ir_armb
class	ir_arml
class	ir_armtb
class	ir_armtl

Functions
def	update_flag_zf (a)
def	update_flag_zf_eq (a, b)
def	update_flag_nf (arg)
def	update_flag_zn (a)
def	check_ops_msb (a, b, c)
def	update_flag_add_cf (op1, op2)
def	update_flag_add_of (op1, op2)
def	update_flag_sub_cf (op1, op2)
def	update_flag_sub_of (op1, op2)
def	update_flag_arith_add_co (arg1, arg2)
def	update_flag_arith_add_zn (arg1, arg2)
def	update_flag_arith_sub_co (arg1, arg2)
def	update_flag_arith_sub_zn (arg1, arg2)
def	update_flag_zfaddwc_eq (arg1, arg2, arg3)
def	update_flag_zfsubwc_eq (arg1, arg2, arg3)
def	update_flag_arith_addwc_zn (arg1, arg2, arg3)
def	update_flag_arith_subwc_zn (arg1, arg2, arg3)
def	update_flag_addwc_cf (op1, op2, op3)
def	update_flag_addwc_of (op1, op2, op3)
def	update_flag_arith_addwc_co (arg1, arg2, arg3)
def	update_flag_subwc_cf (op1, op2, op3)
def	update_flag_subwc_of (op1, op2, op3)
def	update_flag_arith_subwc_co (arg1, arg2, arg3)
def	get_dst (a)
def	adc (ir, instr, a, b, c=None)
def	add (ir, instr, a, b, c=None)
def	l_and (ir, instr, a, b, c=None)
def	sub (ir, instr, a, b, c=None)
def	subs (ir, instr, a, b, c=None)
def	eor (ir, instr, a, b, c=None)
def	eors (ir, instr, a, b, c=None)
def	rsb (ir, instr, a, b, c=None)
def	rsbs (ir, instr, a, b, c=None)
def	sbc (ir, instr, a, b, c=None)
def	sbcs (ir, instr, a, b, c=None)
def	rsc (ir, instr, a, b, c=None)
def	rscs (ir, instr, a, b, c=None)
def	tst (ir, instr, a, b)
def	teq (ir, instr, a, b, c=None)
def	l_cmp (ir, instr, a, b, c=None)
def	cmn (ir, instr, a, b, c=None)
def	orr (ir, instr, a, b, c=None)
def	orn (ir, instr, a, b, c=None)
def	orrs (ir, instr, a, b, c=None)
def	mov (ir, instr, a, b)
def	movt (ir, instr, a, b)
def	movs (ir, instr, a, b)
def	mvn (ir, instr, a, b)
def	mvns (ir, instr, a, b)
def	mrs (ir, instr, a, b)
def	msr (ir, instr, a, b)
def	neg (ir, instr, a, b)
def	negs (ir, instr, a, b)
def	bic (ir, instr, a, b, c=None)
def	bics (ir, instr, a, b, c=None)
def	sdiv (ir, instr, a, b, c=None)
def	udiv (ir, instr, a, b, c=None)
def	mla (ir, instr, a, b, c, d)
def	mlas (ir, instr, a, b, c, d)
def	mls (ir, instr, a, b, c, d)
def	mul (ir, instr, a, b, c=None)
def	muls (ir, instr, a, b, c=None)
def	umull (ir, instr, a, b, c, d)
def	umlal (ir, instr, a, b, c, d)
def	smull (ir, instr, a, b, c, d)
def	smlal (ir, instr, a, b, c, d)
def	b (ir, instr, a)
def	bl (ir, instr, a)
def	bx (ir, instr, a)
def	blx (ir, instr, a)
def	st_ld_r (ir, instr, a, a2, b, store=False, size=32, s_ext=False, z_ext=False)
def	ldr (ir, instr, a, b)
def	ldrd (ir, instr, a, b, c=None)
def	l_str (ir, instr, a, b)
def	l_strd (ir, instr, a, b, c=None)
def	ldrb (ir, instr, a, b)
def	ldrsb (ir, instr, a, b)
def	strb (ir, instr, a, b)
def	ldrh (ir, instr, a, b)
def	strh (ir, instr, a, b)
def	ldrsh (ir, instr, a, b)
def	st_ld_m (ir, instr, a, b, store=False, postinc=False, updown=False)
def	ldmia (ir, instr, a, b)
def	ldmib (ir, instr, a, b)
def	ldmda (ir, instr, a, b)
def	ldmdb (ir, instr, a, b)
def	stmia (ir, instr, a, b)
def	stmib (ir, instr, a, b)
def	stmda (ir, instr, a, b)
def	stmdb (ir, instr, a, b)
def	svc (ir, instr, a)
def	und (ir, instr, a, b)
def	lsr (ir, instr, a, b, c=None)
def	lsrs (ir, instr, a, b, c=None)
def	asr (ir, instr, a, b, c=None)
def	asrs (ir, instr, a, b, c=None)
def	lsl (ir, instr, a, b, c=None)
def	lsls (ir, instr, a, b, c=None)
def	rors (ir, instr, a, b)
def	push (ir, instr, a)
def	pop (ir, instr, a)
def	cbz (ir, instr, a, b)
def	cbnz (ir, instr, a, b)
def	uxtb (ir, instr, a, b)
def	uxth (ir, instr, a, b)
def	sxtb (ir, instr, a, b)
def	sxth (ir, instr, a, b)
def	ubfx (ir, instr, a, b, c, d)
def	bfc (ir, instr, a, b, c)
def	pld (ir, instr, a)
def	pldw (ir, instr, a)
def	clz (ir, instr, a, b)
def	uxtab (ir, instr, a, b, c)
def	uxtah (ir, instr, a, b, c)
def	bkpt (ir, instr, a)
def	smul (ir, instr, a, b, c)
def	smulw (ir, instr, a, b, c)
def	tbb (ir, instr, a)
def	tbh (ir, instr, a)
def	smlabb (ir, instr, a, b, c, d)
def	smlabt (ir, instr, a, b, c, d)
def	smlatb (ir, instr, a, b, c, d)
def	smlatt (ir, instr, a, b, c, d)
def	uadd8 (ir, instr, a, b, c)
def	sel (ir, instr, a, b, c)
def	rev (ir, instr, a, b)
def	rev16 (ir, instr, a, b)
def	nop (ir, instr)
def	dsb (ir, instr, a)
def	isb (ir, instr, a)
def	cpsie (ir, instr, a)
def	cpsid (ir, instr, a)
def	wfe (ir, instr)
def	wfi (ir, instr)
def	adr (ir, instr, arg1, arg2)
def	pkhbt (ir, instr, arg1, arg2, arg3)
def	pkhtb (ir, instr, arg1, arg2, arg3)
def	mrc (ir, insr, arg1, arg2, arg3, arg4, arg5, arg6)
def	mcr (ir, insr, arg1, arg2, arg3, arg4, arg5, arg6)
def	is_pc_written (ir, instr_ir)
def	add_condition_expr (ir, instr, cond, instr_ir, extra_ir)
def	split_expr_dst (ir, instr_ir)
def	get_mnemo_expr (ir, instr, *args)

Variables
dictionary	coproc_reg_dict
tuple	EXCEPT_SOFT_BP = (1 << 1)
tuple	EXCEPT_PRIV_INSN = (1 << 17)
int	COND_EQ = 0
int	COND_NE = 1
int	COND_CS = 2
int	COND_CC = 3
int	COND_MI = 4
int	COND_PL = 5
int	COND_VS = 6
int	COND_VC = 7
int	COND_HI = 8
int	COND_LS = 9
int	COND_GE = 10
int	COND_LT = 11
int	COND_GT = 12
int	COND_LE = 13
int	COND_AL = 14
int	COND_NV = 15
dictionary	cond_dct
	cond_dct_inv = dict((name, num) for num, name in viewitems(cond_dct))
dictionary	tab_cond
dictionary	mnemo_func = {}
dictionary	mnemo_func_cond = {}
dictionary	mnemo_condm0
dictionary	mnemo_condm1
dictionary	mnemo_condm2
dictionary	mnemo_nocond
list	mn_cond_x
string	cn = ""
string	mn_mod = mn + cn
def	get_arm_instr_expr = get_mnemo_expr

Function Documentation

adc()

def miasm.arch.arm.sem.adc	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

add()

def miasm.arch.arm.sem.add	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

add_condition_expr()

def miasm.arch.arm.sem.add_condition_expr	(		ir,
			instr,
			cond,
			instr_ir,
			extra_ir
	)

Here is the caller graph for this function:

adr()

def miasm.arch.arm.sem.adr	(		ir,
			instr,
			arg1,
			arg2
	)

asr()

def miasm.arch.arm.sem.asr	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

asrs()

def miasm.arch.arm.sem.asrs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

b()

def miasm.arch.arm.sem.b	(		ir,
			instr,
			a
	)

bfc()

def miasm.arch.arm.sem.bfc	(		ir,
			instr,
			a,
			b,
			c
	)

bic()

def miasm.arch.arm.sem.bic	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

bics()

def miasm.arch.arm.sem.bics	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

bkpt()

def miasm.arch.arm.sem.bkpt	(		ir,
			instr,
			a
	)

bl()

def miasm.arch.arm.sem.bl	(		ir,
			instr,
			a
	)

blx()

def miasm.arch.arm.sem.blx	(		ir,
			instr,
			a
	)

bx()

def miasm.arch.arm.sem.bx	(		ir,
			instr,
			a
	)

cbnz()

def miasm.arch.arm.sem.cbnz	(		ir,
			instr,
			a,
			b
	)

cbz()

def miasm.arch.arm.sem.cbz	(		ir,
			instr,
			a,
			b
	)

check_ops_msb()

def miasm.arch.arm.sem.check_ops_msb	(		a,
			b,
			c
	)

clz()

def miasm.arch.arm.sem.clz	(		ir,
			instr,
			a,
			b
	)

cmn()

def miasm.arch.arm.sem.cmn	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

cpsid()

def miasm.arch.arm.sem.cpsid	(		ir,
			instr,
			a
	)

cpsie()

def miasm.arch.arm.sem.cpsie	(		ir,
			instr,
			a
	)

dsb()

def miasm.arch.arm.sem.dsb	(		ir,
			instr,
			a
	)

eor()

def miasm.arch.arm.sem.eor	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

eors()

def miasm.arch.arm.sem.eors	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

get_dst()

def miasm.arch.arm.sem.get_dst

(

a

)

Here is the caller graph for this function:

get_mnemo_expr()

def miasm.arch.arm.sem.get_mnemo_expr	(		ir,
			instr,
		*	args
	)

Here is the call graph for this function:

Here is the caller graph for this function:

is_pc_written()

def miasm.arch.arm.sem.is_pc_written	(		ir,
			instr_ir
	)

isb()

def miasm.arch.arm.sem.isb	(		ir,
			instr,
			a
	)

l_and()

def miasm.arch.arm.sem.l_and	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

l_cmp()

def miasm.arch.arm.sem.l_cmp	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

l_str()

def miasm.arch.arm.sem.l_str	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

l_strd()

def miasm.arch.arm.sem.l_strd	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

ldmda()

def miasm.arch.arm.sem.ldmda	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldmdb()

def miasm.arch.arm.sem.ldmdb	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldmia()

def miasm.arch.arm.sem.ldmia	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldmib()

def miasm.arch.arm.sem.ldmib	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldr()

def miasm.arch.arm.sem.ldr	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldrb()

def miasm.arch.arm.sem.ldrb	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldrd()

def miasm.arch.arm.sem.ldrd	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

ldrh()

def miasm.arch.arm.sem.ldrh	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldrsb()

def miasm.arch.arm.sem.ldrsb	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

ldrsh()

def miasm.arch.arm.sem.ldrsh	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

lsl()

def miasm.arch.arm.sem.lsl	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

lsls()

def miasm.arch.arm.sem.lsls	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

lsr()

def miasm.arch.arm.sem.lsr	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

lsrs()

def miasm.arch.arm.sem.lsrs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

mcr()

def miasm.arch.arm.sem.mcr	(		ir,
			insr,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6
	)

mla()

def miasm.arch.arm.sem.mla	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

Here is the call graph for this function:

mlas()

def miasm.arch.arm.sem.mlas	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

Here is the call graph for this function:

mls()

def miasm.arch.arm.sem.mls	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

Here is the call graph for this function:

mov()

def miasm.arch.arm.sem.mov	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

movs()

def miasm.arch.arm.sem.movs	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

movt()

def miasm.arch.arm.sem.movt	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

mrc()

def miasm.arch.arm.sem.mrc	(		ir,
			insr,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6
	)

mrs()

def miasm.arch.arm.sem.mrs	(		ir,
			instr,
			a,
			b
	)

msr()

def miasm.arch.arm.sem.msr	(		ir,
			instr,
			a,
			b
	)

mul()

def miasm.arch.arm.sem.mul	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

muls()

def miasm.arch.arm.sem.muls	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

mvn()

def miasm.arch.arm.sem.mvn	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

mvns()

def miasm.arch.arm.sem.mvns	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

neg()

def miasm.arch.arm.sem.neg	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

negs()

def miasm.arch.arm.sem.negs	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

nop()

def miasm.arch.arm.sem.nop	(		ir,
			instr
	)

orn()

def miasm.arch.arm.sem.orn	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

orr()

def miasm.arch.arm.sem.orr	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

orrs()

def miasm.arch.arm.sem.orrs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

pkhbt()

def miasm.arch.arm.sem.pkhbt	(		ir,
			instr,
			arg1,
			arg2,
			arg3
	)

pkhtb()

def miasm.arch.arm.sem.pkhtb	(		ir,
			instr,
			arg1,
			arg2,
			arg3
	)

pld()

def miasm.arch.arm.sem.pld	(		ir,
			instr,
			a
	)

pldw()

def miasm.arch.arm.sem.pldw	(		ir,
			instr,
			a
	)

pop()

def miasm.arch.arm.sem.pop	(		ir,
			instr,
			a
	)

Here is the caller graph for this function:

push()

def miasm.arch.arm.sem.push	(		ir,
			instr,
			a
	)

Here is the caller graph for this function:

rev()

def miasm.arch.arm.sem.rev	(		ir,
			instr,
			a,
			b
	)

rev16()

def miasm.arch.arm.sem.rev16	(		ir,
			instr,
			a,
			b
	)

rors()

def miasm.arch.arm.sem.rors	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

rsb()

def miasm.arch.arm.sem.rsb	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

rsbs()

def miasm.arch.arm.sem.rsbs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

rsc()

def miasm.arch.arm.sem.rsc	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

rscs()

def miasm.arch.arm.sem.rscs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

sbc()

def miasm.arch.arm.sem.sbc	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

sbcs()

def miasm.arch.arm.sem.sbcs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

sdiv()

def miasm.arch.arm.sem.sdiv	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

sel()

def miasm.arch.arm.sem.sel	(		ir,
			instr,
			a,
			b,
			c
	)

smlabb()

def miasm.arch.arm.sem.smlabb	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

smlabt()

def miasm.arch.arm.sem.smlabt	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

smlal()

def miasm.arch.arm.sem.smlal	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

smlatb()

def miasm.arch.arm.sem.smlatb	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

smlatt()

def miasm.arch.arm.sem.smlatt	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

smul()

def miasm.arch.arm.sem.smul	(		ir,
			instr,
			a,
			b,
			c
	)

smull()

def miasm.arch.arm.sem.smull	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

smulw()

def miasm.arch.arm.sem.smulw	(		ir,
			instr,
			a,
			b,
			c
	)

split_expr_dst()

def miasm.arch.arm.sem.split_expr_dst	(		ir,
			instr_ir
	)

st_ld_m()

def miasm.arch.arm.sem.st_ld_m	(		ir,
			instr,
			a,
			b,
			store = False,
			postinc = False,
			updown = False
	)

Here is the caller graph for this function:

st_ld_r()

def miasm.arch.arm.sem.st_ld_r	(		ir,
			instr,
			a,
			a2,
			b,
			store = False,
			size = 32,
			s_ext = False,
			z_ext = False
	)

Here is the caller graph for this function:

stmda()

def miasm.arch.arm.sem.stmda	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

stmdb()

def miasm.arch.arm.sem.stmdb	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

stmia()

def miasm.arch.arm.sem.stmia	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

stmib()

def miasm.arch.arm.sem.stmib	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

strb()

def miasm.arch.arm.sem.strb	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

strh()

def miasm.arch.arm.sem.strh	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

sub()

def miasm.arch.arm.sem.sub	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

subs()

def miasm.arch.arm.sem.subs	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

Here is the caller graph for this function:

svc()

def miasm.arch.arm.sem.svc	(		ir,
			instr,
			a
	)

sxtb()

def miasm.arch.arm.sem.sxtb	(		ir,
			instr,
			a,
			b
	)

sxth()

def miasm.arch.arm.sem.sxth	(		ir,
			instr,
			a,
			b
	)

tbb()

def miasm.arch.arm.sem.tbb	(		ir,
			instr,
			a
	)

tbh()

def miasm.arch.arm.sem.tbh	(		ir,
			instr,
			a
	)

teq()

def miasm.arch.arm.sem.teq	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

tst()

def miasm.arch.arm.sem.tst	(		ir,
			instr,
			a,
			b
	)

Here is the call graph for this function:

uadd8()

def miasm.arch.arm.sem.uadd8	(		ir,
			instr,
			a,
			b,
			c
	)

ubfx()

def miasm.arch.arm.sem.ubfx	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

udiv()

def miasm.arch.arm.sem.udiv	(		ir,
			instr,
			a,
			b,
			c = None
	)

Here is the call graph for this function:

umlal()

def miasm.arch.arm.sem.umlal	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

umull()

def miasm.arch.arm.sem.umull	(		ir,
			instr,
			a,
			b,
			c,
			d
	)

und()

def miasm.arch.arm.sem.und	(		ir,
			instr,
			a,
			b
	)

update_flag_add_cf()

def miasm.arch.arm.sem.update_flag_add_cf	(		op1,
			op2
	)

Here is the caller graph for this function:

update_flag_add_of()

def miasm.arch.arm.sem.update_flag_add_of	(		op1,
			op2
	)

Here is the caller graph for this function:

update_flag_addwc_cf()

def miasm.arch.arm.sem.update_flag_addwc_cf	(		op1,
			op2,
			op3
	)

Here is the caller graph for this function:

update_flag_addwc_of()

def miasm.arch.arm.sem.update_flag_addwc_of	(		op1,
			op2,
			op3
	)

Here is the caller graph for this function:

update_flag_arith_add_co()

def miasm.arch.arm.sem.update_flag_arith_add_co	(		arg1,
			arg2
	)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_add_zn()

def miasm.arch.arm.sem.update_flag_arith_add_zn	(		arg1,
			arg2
	)

Compute zf and nf flags for (arg1 + arg2)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_addwc_co()

def miasm.arch.arm.sem.update_flag_arith_addwc_co	(		arg1,
			arg2,
			arg3
	)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_addwc_zn()

def miasm.arch.arm.sem.update_flag_arith_addwc_zn	(		arg1,
			arg2,
			arg3
	)

Compute znp flags for (arg1 + arg2 + cf)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_sub_co()

def miasm.arch.arm.sem.update_flag_arith_sub_co	(		arg1,
			arg2
	)

Compute cf and of flags for (arg1 - arg2)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_sub_zn()

def miasm.arch.arm.sem.update_flag_arith_sub_zn	(		arg1,
			arg2
	)

Compute zf and nf flags for (arg1 - arg2)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_subwc_co()

def miasm.arch.arm.sem.update_flag_arith_subwc_co	(		arg1,
			arg2,
			arg3
	)

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_arith_subwc_zn()

def miasm.arch.arm.sem.update_flag_arith_subwc_zn	(		arg1,
			arg2,
			arg3
	)

Compute znp flags for (arg1 - (arg2 + cf))

Here is the call graph for this function:

Here is the caller graph for this function:

update_flag_nf()

def miasm.arch.arm.sem.update_flag_nf

(

arg

)

Here is the caller graph for this function:

update_flag_sub_cf()

def miasm.arch.arm.sem.update_flag_sub_cf	(		op1,
			op2
	)

Here is the caller graph for this function:

update_flag_sub_of()

def miasm.arch.arm.sem.update_flag_sub_of	(		op1,
			op2
	)

Here is the caller graph for this function:

update_flag_subwc_cf()

def miasm.arch.arm.sem.update_flag_subwc_cf	(		op1,
			op2,
			op3
	)

Here is the caller graph for this function:

update_flag_subwc_of()

def miasm.arch.arm.sem.update_flag_subwc_of	(		op1,
			op2,
			op3
	)

Here is the caller graph for this function:

update_flag_zf()

def miasm.arch.arm.sem.update_flag_zf

(

a

)

Here is the caller graph for this function:

update_flag_zf_eq()

def miasm.arch.arm.sem.update_flag_zf_eq	(		a,
			b
	)

Here is the caller graph for this function:

update_flag_zfaddwc_eq()

def miasm.arch.arm.sem.update_flag_zfaddwc_eq	(		arg1,
			arg2,
			arg3
	)

Here is the caller graph for this function:

update_flag_zfsubwc_eq()

def miasm.arch.arm.sem.update_flag_zfsubwc_eq	(		arg1,
			arg2,
			arg3
	)

Here is the caller graph for this function:

update_flag_zn()

def miasm.arch.arm.sem.update_flag_zn

(

a

)

Here is the call graph for this function:

Here is the caller graph for this function:

uxtab()

def miasm.arch.arm.sem.uxtab	(		ir,
			instr,
			a,
			b,
			c
	)

uxtah()

def miasm.arch.arm.sem.uxtah	(		ir,
			instr,
			a,
			b,
			c
	)

uxtb()

def miasm.arch.arm.sem.uxtb	(		ir,
			instr,
			a,
			b
	)

uxth()

def miasm.arch.arm.sem.uxth	(		ir,
			instr,
			a,
			b
	)

wfe()

def miasm.arch.arm.sem.wfe	(		ir,
			instr
	)

wfi()

def miasm.arch.arm.sem.wfi	(		ir,
			instr
	)

Variable Documentation

cn

string miasm.arch.arm.sem.cn = ""

COND_AL

int miasm.arch.arm.sem.COND_AL = 14

COND_CC

int miasm.arch.arm.sem.COND_CC = 3

COND_CS

int miasm.arch.arm.sem.COND_CS = 2

cond_dct

dictionary miasm.arch.arm.sem.cond_dct

Initial value:

=  {
    COND_EQ: "EQ",
    COND_NE: "NE",
    COND_CS: "CS",
    COND_CC: "CC",
    COND_MI: "MI",
    COND_PL: "PL",
    COND_VS: "VS",
    COND_VC: "VC",
    COND_HI: "HI",
    COND_LS: "LS",
    COND_GE: "GE",
    COND_LT: "LT",
    COND_GT: "GT",
    COND_LE: "LE",
    COND_AL: "AL",
    # COND_NV: "NV",
}

cond_dct_inv

miasm.arch.arm.sem.cond_dct_inv = dict((name, num) for num, name in viewitems(cond_dct))

COND_EQ

int miasm.arch.arm.sem.COND_EQ = 0

COND_GE

int miasm.arch.arm.sem.COND_GE = 10

COND_GT

int miasm.arch.arm.sem.COND_GT = 12

COND_HI

int miasm.arch.arm.sem.COND_HI = 8

COND_LE

int miasm.arch.arm.sem.COND_LE = 13

COND_LS

int miasm.arch.arm.sem.COND_LS = 9

COND_LT

int miasm.arch.arm.sem.COND_LT = 11

COND_MI

int miasm.arch.arm.sem.COND_MI = 4

COND_NE

int miasm.arch.arm.sem.COND_NE = 1

COND_NV

int miasm.arch.arm.sem.COND_NV = 15

COND_PL

int miasm.arch.arm.sem.COND_PL = 5

COND_VC

int miasm.arch.arm.sem.COND_VC = 7

COND_VS

int miasm.arch.arm.sem.COND_VS = 6

coproc_reg_dict

dictionary miasm.arch.arm.sem.coproc_reg_dict

EXCEPT_PRIV_INSN

tuple miasm.arch.arm.sem.EXCEPT_PRIV_INSN = (1 << 17)

EXCEPT_SOFT_BP

tuple miasm.arch.arm.sem.EXCEPT_SOFT_BP = (1 << 1)

get_arm_instr_expr

def miasm.arch.arm.sem.get_arm_instr_expr = get_mnemo_expr

mn_cond_x

list miasm.arch.arm.sem.mn_cond_x

Initial value:

=  [mnemo_condm0,
             mnemo_condm1,
             mnemo_condm2]

mn_mod

string miasm.arch.arm.sem.mn_mod = mn + cn

mnemo_condm0

dictionary miasm.arch.arm.sem.mnemo_condm0

mnemo_condm1

dictionary miasm.arch.arm.sem.mnemo_condm1

Initial value:

=  {'adds': add,
                'subs': subs,
                'eors': eors,
                'ands': l_and,
                'rsbs': rsbs,
                'adcs': adc,
                'sbcs': sbcs,
                'rscs': rscs,
 
                'orrs': orrs,
                'movs': movs,
                'bics': bics,
                'mvns': mvns,
 
                'mrs': mrs,
                'msr': msr,
 
                'negs': negs,
 
                'muls': muls,
                'mls': mls,
                'mlas': mlas,
                'blx': blx,
 
                'ldrb': ldrb,
                'ldsb': ldrsb,
                'strb': strb,
                }

mnemo_condm2

dictionary miasm.arch.arm.sem.mnemo_condm2

Initial value:

=  {'ldmia': ldmia,
                'ldmib': ldmib,
                'ldmda': ldmda,
                'ldmdb': ldmdb,
 
                'ldmfa': ldmda,
                'ldmfd': ldmia,
                'ldmea': ldmdb,
                'ldmed': ldmib,  # XXX
 
 
                'stmia': stmia,
                'stmib': stmib,
                'stmda': stmda,
                'stmdb': stmdb,
 
                'stmfa': stmib,
                'stmed': stmda,
                'stmfd': stmdb,
                'stmea': stmia,
                }

mnemo_func

dictionary miasm.arch.arm.sem.mnemo_func = {}

mnemo_func_cond

dictionary miasm.arch.arm.sem.mnemo_func_cond = {}

mnemo_nocond

dictionary miasm.arch.arm.sem.mnemo_nocond

tab_cond

dictionary miasm.arch.arm.sem.tab_cond

Initial value:

=  {COND_EQ: ExprOp("CC_EQ", zf),
            COND_NE: ExprOp("CC_NE", zf),
            COND_CS: ExprOp("CC_U>=", cf ^ ExprInt(1, 1)), # inv cf
            COND_CC: ExprOp("CC_U<", cf ^ ExprInt(1, 1)), # inv cf
            COND_MI: ExprOp("CC_NEG", nf),
            COND_PL: ExprOp("CC_POS", nf),
            COND_VS: ExprOp("CC_sOVR", of),
            COND_VC: ExprOp("CC_sNOOVR", of),
            COND_HI: ExprOp("CC_U>", cf ^ ExprInt(1, 1), zf), # inv cf
            COND_LS: ExprOp("CC_U<=", cf ^ ExprInt(1, 1), zf), # inv cf
            COND_GE: ExprOp("CC_S>=", nf, of),
            COND_LT: ExprOp("CC_S<", nf, of),
            COND_GT: ExprOp("CC_S>", nf, of, zf),
            COND_LE: ExprOp("CC_S<=", nf, of, zf),
            }