Classes
class	additional_info

class	arm_cpreg

class	arm_deref

class	arm_gpreg

class	arm_gpreg_h

class	arm_gpreg_l

class	arm_gpreg_l_noarg

class	arm_gpreg_noarg

class	arm_gpreg_nosppc

class	arm_imm

class	arm_imm8_12

class	arm_imm_4_12

class	arm_immed

class	arm_off7

class	arm_off8sppc

class	arm_offbw

class	arm_offh

class	arm_offpc

class	arm_offreg

class	arm_offs

class	arm_offs_blx

class	arm_offsp

class	arm_offspc

class	arm_op2

class	arm_op2imm

class	arm_preg

class	arm_psr

class	arm_reg

class	arm_reg_wb

class	arm_reg_wb_nosp

class	arm_rlist

class	arm_sp

class	arm_sppc

class	arm_widthm1

class	armt2_imm10l

class	armt2_imm11l

class	armt2_imm12

class	armt2_rot_rm

class	armt_gpreg_rm_shift_off

class	armt_imm5_1

class	armt_reg_wb

class	armt_rlist

class	armt_rlist_pclr

class	bs_lnk

class	instruction_arm

class	instruction_armt

class	mn_arm

class	mn_armt

class	mul_part_x

class	mul_part_y

class	ppi_b_nosp_mn

class	ppi_b_sp_mn

class	updown_b_nosp_mn

class	updown_b_sp_mn

Functions
def	tok_reg_duo

def	check_bounds

def	reglistparse

def	op_shift2expr

def	shift2expr

def	ast_id2expr

def	ast_int2expr

def	deref2expr_nooff

def	deref2expr_pre

def	deref2expr_pre_mem

def	deref2expr_post

def	deref_wb

def	parsegpreg_wb

def	permut_args

def	reglist2str

def	armop

def	armtop

Variables
tuple	log = logging.getLogger("armdis")

tuple	console_handler = logging.StreamHandler()

tuple	reg_dum = ExprId('DumReg')

list	regs_str = ['R%d' % r for r in xrange(0x10)]

list	regs_expr = [ExprId(x, 32) for x in regs_str]

tuple	gpregs = reg_info(regs_str, regs_expr)

tuple	gpregs_pc = reg_info(regs_str[-1:], regs_expr[-1:])

tuple	gpregs_sp = reg_info(regs_str[13:14], regs_expr[13:14])

tuple	gpregs_nosppc

string	sr_flags = "cxsf"

list	cpsr_regs_str = []

list	spsr_regs_str = []

string	o = ""

list	cpsr_regs_expr = [ExprId(x, 32) for x in cpsr_regs_str]

list	spsr_regs_expr = [ExprId(x, 32) for x in spsr_regs_str]

tuple	cpsr_regs = reg_info(cpsr_regs_str, cpsr_regs_expr)

tuple	spsr_regs = reg_info(spsr_regs_str, spsr_regs_expr)

list	cpregs_str = ['c%d' % r for r in xrange(0x10)]

list	cpregs_expr = [ExprId(x) for x in cpregs_str]

tuple	cp_regs = reg_info(cpregs_str, cpregs_expr)

list	pregs_str = ['p%d' % r for r in xrange(0x10)]

list	pregs_expr = [ExprId(x) for x in pregs_str]

tuple	p_regs = reg_info(pregs_str, pregs_expr)

list	conditional_branch

list	unconditional_branch = ["B", "BX", "BL", "BLX"]

tuple	LPARENTHESIS = Literal("(")

tuple	RPARENTHESIS = Literal(")")

tuple	LACC = Suppress(Literal("{"))

tuple	RACC = Suppress(Literal("}"))

tuple	MINUS = Suppress(Literal("-"))

tuple	CIRCUNFLEX = Literal("^")

tuple	int_1_31 = str_int.copy()

tuple	int_1_32 = str_int.copy()

list	allshifts = ['<<', '>>', 'a>>', '>>>', 'rrx']

list	allshifts_armt = ['<<', '>>', 'a>>', '>>>', 'rrx']

dictionary	shift2expr_dct

tuple	expr2shift_dct = dict([(x[1], x[0]) for x in shift2expr_dct.items()])

tuple	reg_duo

	reg_or_duo = reg_duo\|gpregs.parser

tuple	gpreg_list

tuple	LBRACK = Suppress("[")

tuple	RBRACK = Suppress("]")

tuple	COMMA = Suppress(",")

tuple	all_binaryop_1_31_shifts_t

tuple	all_binaryop_1_32_shifts_t

tuple	all_unaryop_shifts_t = literal_list(['RRX'])

tuple	allshifts_t_armt

	gpreg_p = gpregs.parser

	psr_p = cpsr_regs.parser\|spsr_regs.parser

	int_or_expr = base_expr

tuple	my_var_parser = parse_ast(ast_id2expr, ast_int2expr)

tuple	shift_off

tuple	deref_nooff

tuple	deref_pre

tuple	deref_post

tuple	deref

tuple	gpregs_wb = Group(gpregs.parser + Optional('!'))

list	cond_list

tuple	cond_dct = dict([(x[1], x[0]) for x in enumerate(cond_list)])

tuple	bm_cond = bs_mod_name(l=4, fname='cond', mn_mod=cond_list)

tuple	accum = bs(l=1)

tuple	scc = bs_mod_name(l=1, fname='scc', mn_mod=['', 'S'])

tuple	dumscc = bs("1")

tuple	rd = bs(l=4, cls=(arm_gpreg,))

tuple	rdl = bs(l=4, cls=(arm_gpreg,))

tuple	rn = bs(l=4, cls=(arm_gpreg,), fname="rn")

tuple	rs = bs(l=4, cls=(arm_gpreg,))

tuple	rm = bs(l=4, cls=(arm_gpreg,))

tuple	op2 = bs(l=12, cls=(arm_op2,))

tuple	lnk = bs_lnk(l=1, fname='lnk', mn_mod=['', 'L'])

tuple	offs = bs(l=24, cls=(arm_offs,), fname="offs")

tuple	rn_noarg = bs(l=4, cls=(arm_gpreg_noarg,), fname="rn")

tuple	rm_noarg = bs(l=4, cls=(arm_gpreg_noarg,), fname="rm", order = -1)

tuple	immop = bs(l=1, fname='immop')

tuple	dumr = bs(l=4, default_val="0000", fname="dumr")

tuple	psr = bs(l=1, fname="psr")

tuple	psr_field = bs(l=4, cls=(arm_psr,))

tuple	ppi = bs(l=1, fname='ppi')

tuple	updown = bs(l=1, fname='updown')

tuple	trb = bs_mod_name(l=1, fname='trb', mn_mod=['', 'B'])

tuple	wback = bs_mod_name(l=1, fname="wback", mn_mod=['', 'T'])

tuple	wback_no_t = bs(l=1, fname="wback")

tuple	op2imm = bs(l=12, cls=(arm_op2imm,))

tuple	updown_b_nosp = updown_b_nosp_mn(l=1, mn_mod=['D', 'I'], fname='updown')

tuple	ppi_b_nosp = ppi_b_nosp_mn(l=1, mn_mod=['A', 'B'], fname='ppi')

tuple	updown_b_sp = updown_b_sp_mn(l=1, mn_mod=['A', 'D'], fname='updown')

tuple	ppi_b_sp = ppi_b_sp_mn(l=1, mn_mod=['F', 'E'], fname='ppi')

tuple	sbit = bs(l=1, fname="sbit")

tuple	rn_sp = bs("1101", cls=(arm_reg_wb,), fname='rnsp')

tuple	rn_wb = bs(l=4, cls=(arm_reg_wb_nosp,), fname='rn')

tuple	rlist = bs(l=16, cls=(arm_rlist,), fname='rlist')

tuple	swi_i = bs(l=24, cls=(arm_imm,), fname="swi_i")

tuple	opc = bs(l=4, cls=(arm_imm, m_arg), fname='opc')

tuple	crn = bs(l=4, cls=(arm_cpreg,), fname='crn')

tuple	crd = bs(l=4, cls=(arm_cpreg,), fname='crd')

tuple	crm = bs(l=4, cls=(arm_cpreg,), fname='crm')

tuple	cpnum = bs(l=4, cls=(arm_preg,), fname='cpnum')

tuple	cp = bs(l=3, cls=(arm_imm, m_arg), fname='cp')

tuple	imm8_12 = bs(l=8, cls=(arm_imm8_12, m_arg), fname='imm')

tuple	tl = bs_mod_name(l=1, fname="tl", mn_mod=['', 'L'])

tuple	cpopc = bs(l=3, cls=(arm_imm, m_arg), fname='cpopc')

tuple	imm20 = bs(l=20, cls=(arm_imm, m_arg))

tuple	imm4 = bs(l=4, cls=(arm_imm, m_arg))

tuple	imm12 = bs(l=12, cls=(arm_imm, m_arg))

tuple	imm16 = bs(l=16, cls=(arm_imm, m_arg))

tuple	imm4_noarg = bs(l=4, fname="imm4")

tuple	imm_4_12 = bs(l=12, cls=(arm_imm_4_12,))

tuple	lowb = bs(l=1, fname='lowb')

tuple	offs_blx = bs(l=24, cls=(arm_offs_blx,), fname="offs")

tuple	fix_cond = bs("1111", fname="cond")

tuple	mul_x = mul_part_x(l=1, fname='x', mn_mod=['B', 'T'])

tuple	mul_y = mul_part_y(l=1, fname='y', mn_mod=['B', 'T'])

tuple	immedH = bs(l=4, fname='immedH')

tuple	immedL = bs(l=4, cls=(arm_immed, m_arg), fname='immedL')

tuple	hb = bs(l=1)

tuple	rot_rm = bs(l=2, cls=(armt2_rot_rm,), fname="rot_rm")

list	op_list

dictionary	data_mov_name = {'MOV': 13, 'MVN': 15}

dictionary	data_test_name = {'TST': 8, 'TEQ': 9, 'CMP': 10, 'CMN': 11}

dictionary	data_name = {}

tuple	bs_data_name = bs_name(l=4, name=data_name)

tuple	bs_data_mov_name = bs_name(l=4, name=data_mov_name)

tuple	bs_data_test_name = bs_name(l=4, name=data_test_name)

dictionary	transfer_name = {'STR': 0, 'LDR': 1}

tuple	bs_transfer_name = bs_name(l=1, name=transfer_name)

dictionary	transferh_name = {'STRH': 0, 'LDRH': 1}

tuple	bs_transferh_name = bs_name(l=1, name=transferh_name)

dictionary	transfer_ldr_name = {'LDRD': 0, 'LDRSB': 1}

tuple	bs_transfer_ldr_name = bs_name(l=1, name=transfer_ldr_name)

dictionary	btransfer_name = {'STM': 0, 'LDM': 1}

tuple	bs_btransfer_name = bs_name(l=1, name=btransfer_name)

dictionary	ctransfer_name = {'STC': 0, 'LDC': 1}

tuple	bs_ctransfer_name = bs_name(l=1, name=ctransfer_name)

dictionary	mr_name = {'MCR': 0, 'MRC': 1}

tuple	bs_mr_name = bs_name(l=1, name=mr_name)

tuple	widthm1 = bs(l=5, cls=(arm_widthm1, m_arg))

tuple	lsb = bs(l=5, cls=(arm_imm, m_arg))

tuple	gpregs_l = reg_info(regs_str[:8], regs_expr[:8])

tuple	gpregs_h = reg_info(regs_str[8:], regs_expr[8:])

tuple	gpregs_sppc

tuple	deref_low

tuple	deref_pc

tuple	deref_sp

tuple	gpregs_l_wb

tuple	off5 = bs(l=5, cls=(arm_imm,), fname="off")

tuple	off3 = bs(l=3, cls=(arm_imm,), fname="off")

tuple	off8 = bs(l=8, cls=(arm_imm,), fname="off")

tuple	off7 = bs(l=7, cls=(arm_off7,), fname="off")

tuple	rnl = bs(l=3, cls=(arm_gpreg_l,), fname="rn")

tuple	rsl = bs(l=3, cls=(arm_gpreg_l,), fname="rs")

tuple	rml = bs(l=3, cls=(arm_gpreg_l,), fname="rm")

tuple	rol = bs(l=3, cls=(arm_gpreg_l,), fname="ro")

tuple	rbl = bs(l=3, cls=(arm_gpreg_l,), fname="rb")

tuple	rbl_deref = bs(l=3, cls=(arm_deref,), fname="rb")

tuple	dumrh = bs(l=3, default_val="000")

tuple	rdh = bs(l=3, cls=(arm_gpreg_h,), fname="rd")

tuple	rsh = bs(l=3, cls=(arm_gpreg_h,), fname="rs")

tuple	offpc8 = bs(l=8, cls=(arm_offpc,), fname="offs")

tuple	offsp8 = bs(l=8, cls=(arm_offsp,), fname="offs")

tuple	rol_noarg = bs(l=3, cls=(arm_gpreg_l_noarg,), fname="off")

tuple	off5bw = bs(l=5, cls=(arm_offbw,), fname="off")

tuple	off5h = bs(l=5, cls=(arm_offh,), fname="off")

tuple	sppc = bs(l=1, cls=(arm_sppc,))

tuple	pclr = bs(l=1, fname='pclr')

tuple	sp = bs(l=0, cls=(arm_sp,))

tuple	off8s = bs(l=8, cls=(arm_offs,), fname="offs")

tuple	trlistpclr = bs(l=8, cls=(armt_rlist_pclr,))

tuple	trlist = bs(l=8, cls=(armt_rlist,), fname="trlist", order = -1)

tuple	rbl_wb = bs(l=3, cls=(armt_reg_wb,), fname='rb')

tuple	offs8 = bs(l=8, cls=(arm_offspc,), fname="offs")

tuple	offs11 = bs(l=11, cls=(arm_offspc,), fname="offs")

tuple	hl = bs(l=1, prio=default_prio + 1, fname='hl')

tuple	off8sppc = bs(l=8, cls=(arm_off8sppc,), fname="off")

tuple	imm8_d1 = bs(l=8, default_val="00000001")

tuple	imm8 = bs(l=8, cls=(arm_imm,), default_val = "00000001")

dictionary	mshift_name = {'LSLS': 0, 'LSRS': 1, 'ASRS': 2}

tuple	bs_mshift_name = bs_name(l=2, name=mshift_name)

dictionary	addsub_name = {'ADDS': 0, 'SUBS': 1}

tuple	bs_addsub_name = bs_name(l=1, name=addsub_name)

dictionary	mov_cmp_add_sub_name = {'MOVS': 0, 'CMP': 1, 'ADDS': 2, 'SUBS': 3}

tuple	bs_mov_cmp_add_sub_name = bs_name(l=2, name=mov_cmp_add_sub_name)

dictionary	alu_name

tuple	bs_alu_name = bs_name(l=4, name=alu_name)

dictionary	hiregop_name = {'ADDS': 0, 'CMP': 1, 'MOV': 2}

tuple	bs_hiregop_name = bs_name(l=2, name=hiregop_name)

dictionary	ldr_str_name = {'STR': 0, 'LDR': 1}

tuple	bs_ldr_str_name = bs_name(l=1, name=ldr_str_name)

dictionary	ldrh_strh_name = {'STRH': 0, 'LDRH': 1}

tuple	bs_ldrh_strh_name = bs_name(l=1, name=ldrh_strh_name)

dictionary	ldstsp_name = {'STR': 0, 'LDR': 1}

tuple	bs_ldstsp_name = bs_name(l=1, name=ldstsp_name)

dictionary	addsubsp_name = {'ADD': 0, 'SUB': 1}

tuple	bs_addsubsp_name = bs_name(l=1, name=addsubsp_name)

dictionary	pushpop_name = {'PUSH': 0, 'POP': 1}

tuple	bs_pushpop_name = bs_name(l=1, name=pushpop_name, fname='pp')

dictionary	tbtransfer_name = {'STMIA': 0, 'LDMIA': 1}

tuple	bs_tbtransfer_name = bs_name(l=1, name=tbtransfer_name)

dictionary	br_name

tuple	bs_br_name = bs_name(l=4, name=br_name)

tuple	armt_gpreg_shift_off

tuple	rn_nosppc = bs(l=4, cls=(arm_gpreg_nosppc,), fname="rn")

tuple	rd_nosppc = bs(l=4, cls=(arm_gpreg_nosppc,), fname="rd")

tuple	rm_sh = bs(l=4, cls=(armt_gpreg_rm_shift_off,), fname="rm")

tuple	imm12_1 = bs(l=1, fname="imm12_1", order=1)

tuple	imm12_3 = bs(l=3, fname="imm12_3", order=1)

tuple	imm12_8 = bs(l=8, cls=(armt2_imm12,), fname="imm", order=2)

tuple	imm5_3 = bs(l=3, fname="imm5_3")

tuple	imm5_2 = bs(l=2, fname="imm5_2")

tuple	imm_stype = bs(l=2, fname="stype")

tuple	imm1 = bs(l=1, fname="imm1")

tuple	imm5_off = bs(l=5, cls=(armt_imm5_1,), fname="imm5_off")

tuple	tsign = bs(l=1, fname="sign")

tuple	tj1 = bs(l=1, fname="j1")

tuple	tj2 = bs(l=1, fname="j2")

tuple	timm10H = bs(l=10, fname="imm10h")

tuple	timm10L = bs(l=10, cls=(armt2_imm10l,), fname="imm10l")

tuple	timm11L = bs(l=11, cls=(armt2_imm11l,), fname="imm11l")

Function Documentation

def miasm2.arch.arm.arch.armop	(	name,
		fields,
		args = `None`,
		alias = `False`
	)

Definition at line 1405 of file arch.py.

 
 def armop(name, fields, args=None, alias=False):
     dct = {"fields": fields}
     dct["alias"] = alias
     if args is not None:
         dct['args'] = args
     type(name, (mn_arm,), dct)
 

miasm2.arch.arm.arch.armop

def armop

Definition: arch.py:1405

type

def miasm2.arch.arm.arch.check_bounds	(	left_bound,
		right_bound,
		value
	)

def miasm2.arch.arm.arch.armtop	(	name,
		fields,
		args = `None`,
		alias = `False`
	)

def miasm2.arch.arm.arch.deref2expr_nooff	(	s,
		l,
		t
	)

def miasm2.arch.arm.arch.deref2expr_post	(	s,
		l,
		t
	)

def miasm2.arch.arm.arch.deref2expr_pre	(	s,
		l,
		t
	)

def miasm2.arch.arm.arch.deref2expr_pre_mem	(	s,
		l,
		t
	)

Classes

Functions

Variables

Function Documentation

Variable Documentation