miasm.arch.x86.regs Namespace Reference

Variables
	IP = ExprId('IP', 16)
	EIP = ExprId('EIP', 32)
	RIP = ExprId('RIP', 64)
	exception_flags = ExprId('exception_flags', 32)
	interrupt_num = ExprId('interrupt_num', 8)
list	regs08_str = ["AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"] + \
list	regs08_expr = [ExprId(x, 8) for x in regs08_str]
list	regs08_64_str = ["AL", "CL", "DL", "BL", "SPL", "BPL", "SIL", "DIL"] + \
list	regs08_64_expr = [ExprId(x, 8) for x in regs08_64_str]
list	regs16_str = ["AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"] + \
list	regs16_expr = [ExprId(x, 16) for x in regs16_str]
list	regs32_str = ["EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"] + \
list	regs32_expr = [ExprId(x, 32) for x in regs32_str]
list	regs64_str
list	regs64_expr = [ExprId(x, 64) for x in regs64_str]
list	regs_xmm_str = ["XMM%d" % i for i in range(16)]
list	regs_xmm_expr = [ExprId(x, 128) for x in regs_xmm_str]
list	regs_mm_str = ["MM%d" % i for i in range(16)]
list	regs_mm_expr = [ExprId(x, 64) for x in regs_mm_str]
list	regs_bnd_str = ["BND%d" % i for i in range(4)]
list	regs_bnd_expr = [ExprId(x, 128) for x in regs_bnd_str]
	gpregs08 = reg_info(regs08_str, regs08_expr)
	gpregs08_64 = reg_info(regs08_64_str, regs08_64_expr)
	gpregs16 = reg_info(regs16_str, regs16_expr)
	gpregs32 = reg_info(regs32_str, regs32_expr)
	gpregs64 = reg_info(regs64_str, regs64_expr)
	gpregs_xmm = reg_info(regs_xmm_str, regs_xmm_expr)
	gpregs_mm = reg_info(regs_mm_str, regs_mm_expr)
	gpregs_bnd = reg_info(regs_bnd_str, regs_bnd_expr)
	r08_eax = reg_info([regs08_str[0]], [regs08_expr[0]])
	r16_eax = reg_info([regs16_str[0]], [regs16_expr[0]])
	r32_eax = reg_info([regs32_str[0]], [regs32_expr[0]])
	r64_eax = reg_info([regs64_str[0]], [regs64_expr[0]])
	r08_ecx = reg_info([regs08_str[1]], [regs08_expr[1]])
	r_eax_all
	r_edx_all
	r16_edx = reg_info([regs16_str[2]], [regs16_expr[2]])
list	selectr_str = ["ES", "CS", "SS", "DS", "FS", "GS"]
list	selectr_expr = [ExprId(x, 16) for x in selectr_str]
	segmreg = reg_info(selectr_str, selectr_expr)
list	crregs32_str = ["CR%d" % i for i in range(8)]
list	crregs32_expr = [ExprId(x, 32) for x in crregs32_str]
	crregs = reg_info(crregs32_str, crregs32_expr)
list	drregs32_str = ["DR%d" % i for i in range(8)]
list	drregs32_expr = [ExprId(x, 32) for x in drregs32_str]
	drregs = reg_info(drregs32_str, drregs32_expr)
list	fltregs32_str = ["ST(%d)" % i for i in range(8)]
list	fltregs32_expr = [ExprId(x, 64) for x in fltregs32_str]
	fltregs = reg_info(fltregs32_str, fltregs32_expr)
	r_st_all
	r_cs_all
	r_ds_all
	r_es_all
	r_ss_all
	r_fs_all
	r_gs_all
list	AL = regs08_expr[0]
list	CL = regs08_expr[1]
list	DL = regs08_expr[2]
list	BL = regs08_expr[3]
list	AH = regs08_expr[4]
list	CH = regs08_expr[5]
list	DH = regs08_expr[6]
list	BH = regs08_expr[7]
list	R8B = regs08_expr[8]
list	R9B = regs08_expr[9]
list	R10B = regs08_expr[10]
list	R11B = regs08_expr[11]
list	R12B = regs08_expr[12]
list	R13B = regs08_expr[13]
list	R14B = regs08_expr[14]
list	R15B = regs08_expr[15]
list	SPL = regs08_64_expr[4]
list	BPL = regs08_64_expr[5]
list	SIL = regs08_64_expr[6]
list	DIL = regs08_64_expr[7]
list	AX = regs16_expr[0]
list	CX = regs16_expr[1]
list	DX = regs16_expr[2]
list	BX = regs16_expr[3]
list	SP = regs16_expr[4]
list	BP = regs16_expr[5]
list	SI = regs16_expr[6]
list	DI = regs16_expr[7]
list	R8W = regs16_expr[8]
list	R9W = regs16_expr[9]
list	R10W = regs16_expr[10]
list	R11W = regs16_expr[11]
list	R12W = regs16_expr[12]
list	R13W = regs16_expr[13]
list	R14W = regs16_expr[14]
list	R15W = regs16_expr[15]
list	EAX = regs32_expr[0]
list	ECX = regs32_expr[1]
list	EDX = regs32_expr[2]
list	EBX = regs32_expr[3]
list	ESP = regs32_expr[4]
list	EBP = regs32_expr[5]
list	ESI = regs32_expr[6]
list	EDI = regs32_expr[7]
list	R8D = regs32_expr[8]
list	R9D = regs32_expr[9]
list	R10D = regs32_expr[10]
list	R11D = regs32_expr[11]
list	R12D = regs32_expr[12]
list	R13D = regs32_expr[13]
list	R14D = regs32_expr[14]
list	R15D = regs32_expr[15]
list	RAX = regs64_expr[0]
list	RCX = regs64_expr[1]
list	RDX = regs64_expr[2]
list	RBX = regs64_expr[3]
list	RSP = regs64_expr[4]
list	RBP = regs64_expr[5]
list	RSI = regs64_expr[6]
list	RDI = regs64_expr[7]
list	R8 = regs64_expr[8]
list	R9 = regs64_expr[9]
list	R10 = regs64_expr[10]
list	R11 = regs64_expr[11]
list	R12 = regs64_expr[12]
list	R13 = regs64_expr[13]
list	R14 = regs64_expr[14]
list	R15 = regs64_expr[15]
string	reg_zf = 'zf'
string	reg_nf = 'nf'
string	reg_pf = 'pf'
string	reg_of = 'of'
string	reg_cf = 'cf'
string	reg_tf = 'tf'
string	reg_if = 'i_f'
string	reg_df = 'df'
string	reg_af = 'af'
string	reg_iopl = 'iopl_f'
string	reg_nt = 'nt'
string	reg_rf = 'rf'
string	reg_vm = 'vm'
string	reg_ac = 'ac'
string	reg_vif = 'vif'
string	reg_vip = 'vip'
string	reg_id = 'i_d'
string	reg_es = "ES"
string	reg_cs = "CS"
string	reg_ss = "SS"
string	reg_ds = "DS"
string	reg_fs = "FS"
string	reg_gs = "GS"
string	reg_dr0 = 'DR0'
string	reg_dr1 = 'DR1'
string	reg_dr2 = 'DR2'
string	reg_dr3 = 'DR3'
string	reg_dr4 = 'DR4'
string	reg_dr5 = 'DR5'
string	reg_dr6 = 'DR6'
string	reg_dr7 = 'DR7'
string	reg_cr0 = 'CR0'
string	reg_cr1 = 'CR1'
string	reg_cr2 = 'CR2'
string	reg_cr3 = 'CR3'
string	reg_cr4 = 'CR4'
string	reg_cr5 = 'CR5'
string	reg_cr6 = 'CR6'
string	reg_cr7 = 'CR7'
string	reg_mm0 = 'MM0'
string	reg_mm1 = 'MM1'
string	reg_mm2 = 'MM2'
string	reg_mm3 = 'MM3'
string	reg_mm4 = 'MM4'
string	reg_mm5 = 'MM5'
string	reg_mm6 = 'MM6'
string	reg_mm7 = 'MM7'
string	reg_tsc = "tsc"
string	reg_float_c0 = 'float_c0'
string	reg_float_c1 = 'float_c1'
string	reg_float_c2 = 'float_c2'
string	reg_float_c3 = 'float_c3'
string	reg_float_stack_ptr = "float_stack_ptr"
string	reg_float_control = 'reg_float_control'
string	reg_float_eip = 'reg_float_eip'
string	reg_float_cs = 'reg_float_cs'
string	reg_float_address = 'reg_float_address'
string	reg_float_ds = 'reg_float_ds'
	dr0 = ExprId(reg_dr0, 32)
	dr1 = ExprId(reg_dr1, 32)
	dr2 = ExprId(reg_dr2, 32)
	dr3 = ExprId(reg_dr3, 32)
	dr4 = ExprId(reg_dr4, 32)
	dr5 = ExprId(reg_dr5, 32)
	dr6 = ExprId(reg_dr6, 32)
	dr7 = ExprId(reg_dr7, 32)
	cr0 = ExprId(reg_cr0, 32)
	cr1 = ExprId(reg_cr1, 32)
	cr2 = ExprId(reg_cr2, 32)
	cr3 = ExprId(reg_cr3, 32)
	cr4 = ExprId(reg_cr4, 32)
	cr5 = ExprId(reg_cr5, 32)
	cr6 = ExprId(reg_cr6, 32)
	cr7 = ExprId(reg_cr7, 32)
	mm0 = ExprId(reg_mm0, 64)
	mm1 = ExprId(reg_mm1, 64)
	mm2 = ExprId(reg_mm2, 64)
	mm3 = ExprId(reg_mm3, 64)
	mm4 = ExprId(reg_mm4, 64)
	mm5 = ExprId(reg_mm5, 64)
	mm6 = ExprId(reg_mm6, 64)
	mm7 = ExprId(reg_mm7, 64)
list	XMM0 = regs_xmm_expr[0]
list	XMM1 = regs_xmm_expr[1]
list	XMM2 = regs_xmm_expr[2]
list	XMM3 = regs_xmm_expr[3]
list	XMM4 = regs_xmm_expr[4]
list	XMM5 = regs_xmm_expr[5]
list	XMM6 = regs_xmm_expr[6]
list	XMM7 = regs_xmm_expr[7]
list	XMM8 = regs_xmm_expr[8]
list	XMM9 = regs_xmm_expr[9]
list	XMM10 = regs_xmm_expr[10]
list	XMM11 = regs_xmm_expr[11]
list	XMM12 = regs_xmm_expr[12]
list	XMM13 = regs_xmm_expr[13]
list	XMM14 = regs_xmm_expr[14]
list	XMM15 = regs_xmm_expr[15]
	zf = ExprId(reg_zf, size=1)
	nf = ExprId(reg_nf, size=1)
	pf = ExprId(reg_pf, size=1)
	of = ExprId(reg_of, size=1)
	cf = ExprId(reg_cf, size=1)
	tf = ExprId(reg_tf, size=1)
	i_f = ExprId(reg_if, size=1)
	df = ExprId(reg_df, size=1)
	af = ExprId(reg_af, size=1)
	iopl = ExprId(reg_iopl, size=2)
	nt = ExprId(reg_nt, size=1)
	rf = ExprId(reg_rf, size=1)
	vm = ExprId(reg_vm, size=1)
	ac = ExprId(reg_ac, size=1)
	vif = ExprId(reg_vif, size=1)
	vip = ExprId(reg_vip, size=1)
	i_d = ExprId(reg_id, size=1)
	ES = ExprId(reg_es, size=16)
	CS = ExprId(reg_cs, size=16)
	SS = ExprId(reg_ss, size=16)
	DS = ExprId(reg_ds, size=16)
	FS = ExprId(reg_fs, size=16)
	GS = ExprId(reg_gs, size=16)
	tsc = ExprId(reg_tsc, size=64)
	float_c0 = ExprId(reg_float_c0, size=1)
	float_c1 = ExprId(reg_float_c1, size=1)
	float_c2 = ExprId(reg_float_c2, size=1)
	float_c3 = ExprId(reg_float_c3, size=1)
	float_stack_ptr = ExprId(reg_float_stack_ptr, size=3)
	float_control = ExprId(reg_float_control, 16)
	float_eip = ExprId(reg_float_eip, 32)
	float_cs = ExprId(reg_float_cs, size=16)
	float_address = ExprId(reg_float_address, 32)
	float_ds = ExprId(reg_float_ds, size=16)
	float_st0 = ExprId("float_st0", 64)
	float_st1 = ExprId("float_st1", 64)
	float_st2 = ExprId("float_st2", 64)
	float_st3 = ExprId("float_st3", 64)
	float_st4 = ExprId("float_st4", 64)
	float_st5 = ExprId("float_st5", 64)
	float_st6 = ExprId("float_st6", 64)
	float_st7 = ExprId("float_st7", 64)
list	float_list
dictionary	float_replace = {fltregs32_expr[i]: float_list[i] for i in range(8)}
	EAX_init = ExprId('EAX_init', 32)
	EBX_init = ExprId('EBX_init', 32)
	ECX_init = ExprId('ECX_init', 32)
	EDX_init = ExprId('EDX_init', 32)
	ESI_init = ExprId('ESI_init', 32)
	EDI_init = ExprId('EDI_init', 32)
	ESP_init = ExprId('ESP_init', 32)
	EBP_init = ExprId('EBP_init', 32)
	RAX_init = ExprId('RAX_init', 64)
	RBX_init = ExprId('RBX_init', 64)
	RCX_init = ExprId('RCX_init', 64)
	RDX_init = ExprId('RDX_init', 64)
	RSI_init = ExprId('RSI_init', 64)
	RDI_init = ExprId('RDI_init', 64)
	RSP_init = ExprId('RSP_init', 64)
	RBP_init = ExprId('RBP_init', 64)
list	all_regs_ids
list	all_regs_ids_no_alias
dictionary	attrib_to_regs
	all_regs_ids_byname = dict([(x.name, x) for x in all_regs_ids])
list	all_regs_ids_init = [ExprId("%s_init" % x.name, x.size) for x in all_regs_ids]
dictionary	regs_init = {}
list	regs_flt_expr
dictionary	mRAX = {16: AX, 32: EAX, 64: RAX}
dictionary	mRBX = {16: BX, 32: EBX, 64: RBX}
dictionary	mRCX = {16: CX, 32: ECX, 64: RCX}
dictionary	mRDX = {16: DX, 32: EDX, 64: RDX}
dictionary	mRSI = {16: SI, 32: ESI, 64: RSI}
dictionary	mRDI = {16: DI, 32: EDI, 64: RDI}
dictionary	mRBP = {16: BP, 32: EBP, 64: RBP}
dictionary	mRSP = {16: SP, 32: ESP, 64: RSP}
dictionary	mRIP = {16: IP, 32: EIP, 64: RIP}

Variable Documentation

ac

miasm.arch.x86.regs.ac = ExprId(reg_ac, size=1)

af

miasm.arch.x86.regs.af = ExprId(reg_af, size=1)

AH

list miasm.arch.x86.regs.AH = regs08_expr[4]

AL

list miasm.arch.x86.regs.AL = regs08_expr[0]

all_regs_ids

list miasm.arch.x86.regs.all_regs_ids

all_regs_ids_byname

miasm.arch.x86.regs.all_regs_ids_byname = dict([(x.name, x) for x in all_regs_ids])

all_regs_ids_init

list miasm.arch.x86.regs.all_regs_ids_init = [ExprId("%s_init" % x.name, x.size) for x in all_regs_ids]

all_regs_ids_no_alias

list miasm.arch.x86.regs.all_regs_ids_no_alias

Initial value:

=  [
    RAX, RBX, RCX, RDX, RSP, RBP, RIP, RSI, RDI,
    R8, R9, R10, R11, R12, R13, R14, R15,
    zf, nf, pf, of, cf, af, df,
    tf, i_f, iopl, nt, rf, vm, ac, vif, vip, i_d,
    float_control, float_eip, float_cs, float_address, float_ds,
    tsc,
    ES, CS, SS, DS, FS, GS,
    float_st0, float_st1, float_st2, float_st3,
    float_st4, float_st5, float_st6, float_st7,
    float_c0, float_c1, float_c2, float_c3,
    cr0, cr3,
    dr0, dr1, dr2, dr3, dr4, dr5, dr6, dr7,
    float_stack_ptr,
    mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7,
    XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
    XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15,
 
 
    exception_flags, interrupt_num,
] + fltregs32_expr

attrib_to_regs

dictionary miasm.arch.x86.regs.attrib_to_regs

Initial value:

=  {
    16: regs16_expr + all_regs_ids_no_alias[all_regs_ids_no_alias.index(zf):] + [IP],
    32: regs32_expr + all_regs_ids_no_alias[all_regs_ids_no_alias.index(zf):] + [EIP],
    64: all_regs_ids_no_alias,
}

AX

list miasm.arch.x86.regs.AX = regs16_expr[0]

BH

list miasm.arch.x86.regs.BH = regs08_expr[7]

BL

list miasm.arch.x86.regs.BL = regs08_expr[3]

BP

list miasm.arch.x86.regs.BP = regs16_expr[5]

BPL

list miasm.arch.x86.regs.BPL = regs08_64_expr[5]

BX

list miasm.arch.x86.regs.BX = regs16_expr[3]

cf

miasm.arch.x86.regs.cf = ExprId(reg_cf, size=1)

CH

list miasm.arch.x86.regs.CH = regs08_expr[5]

CL

list miasm.arch.x86.regs.CL = regs08_expr[1]

cr0

miasm.arch.x86.regs.cr0 = ExprId(reg_cr0, 32)

cr1

miasm.arch.x86.regs.cr1 = ExprId(reg_cr1, 32)

cr2

miasm.arch.x86.regs.cr2 = ExprId(reg_cr2, 32)

cr3

miasm.arch.x86.regs.cr3 = ExprId(reg_cr3, 32)

cr4

miasm.arch.x86.regs.cr4 = ExprId(reg_cr4, 32)

cr5

miasm.arch.x86.regs.cr5 = ExprId(reg_cr5, 32)

cr6

miasm.arch.x86.regs.cr6 = ExprId(reg_cr6, 32)

cr7

miasm.arch.x86.regs.cr7 = ExprId(reg_cr7, 32)

crregs

miasm.arch.x86.regs.crregs = reg_info(crregs32_str, crregs32_expr)

crregs32_expr

list miasm.arch.x86.regs.crregs32_expr = [ExprId(x, 32) for x in crregs32_str]

crregs32_str

list miasm.arch.x86.regs.crregs32_str = ["CR%d" % i for i in range(8)]

CS

miasm.arch.x86.regs.CS = ExprId(reg_cs, size=16)

CX

list miasm.arch.x86.regs.CX = regs16_expr[1]

df

miasm.arch.x86.regs.df = ExprId(reg_df, size=1)

DH

list miasm.arch.x86.regs.DH = regs08_expr[6]

DI

list miasm.arch.x86.regs.DI = regs16_expr[7]

DIL

list miasm.arch.x86.regs.DIL = regs08_64_expr[7]

DL

list miasm.arch.x86.regs.DL = regs08_expr[2]

dr0

miasm.arch.x86.regs.dr0 = ExprId(reg_dr0, 32)

dr1

miasm.arch.x86.regs.dr1 = ExprId(reg_dr1, 32)

dr2

miasm.arch.x86.regs.dr2 = ExprId(reg_dr2, 32)

dr3

miasm.arch.x86.regs.dr3 = ExprId(reg_dr3, 32)

dr4

miasm.arch.x86.regs.dr4 = ExprId(reg_dr4, 32)

dr5

miasm.arch.x86.regs.dr5 = ExprId(reg_dr5, 32)

dr6

miasm.arch.x86.regs.dr6 = ExprId(reg_dr6, 32)

dr7

miasm.arch.x86.regs.dr7 = ExprId(reg_dr7, 32)

drregs

miasm.arch.x86.regs.drregs = reg_info(drregs32_str, drregs32_expr)

drregs32_expr

list miasm.arch.x86.regs.drregs32_expr = [ExprId(x, 32) for x in drregs32_str]

drregs32_str

list miasm.arch.x86.regs.drregs32_str = ["DR%d" % i for i in range(8)]

DS

miasm.arch.x86.regs.DS = ExprId(reg_ds, size=16)

DX

list miasm.arch.x86.regs.DX = regs16_expr[2]

EAX

list miasm.arch.x86.regs.EAX = regs32_expr[0]

EAX_init

miasm.arch.x86.regs.EAX_init = ExprId('EAX_init', 32)

EBP

list miasm.arch.x86.regs.EBP = regs32_expr[5]

EBP_init

miasm.arch.x86.regs.EBP_init = ExprId('EBP_init', 32)

EBX

list miasm.arch.x86.regs.EBX = regs32_expr[3]

EBX_init

miasm.arch.x86.regs.EBX_init = ExprId('EBX_init', 32)

ECX

list miasm.arch.x86.regs.ECX = regs32_expr[1]

ECX_init

miasm.arch.x86.regs.ECX_init = ExprId('ECX_init', 32)

EDI

list miasm.arch.x86.regs.EDI = regs32_expr[7]

EDI_init

miasm.arch.x86.regs.EDI_init = ExprId('EDI_init', 32)

EDX

list miasm.arch.x86.regs.EDX = regs32_expr[2]

EDX_init

miasm.arch.x86.regs.EDX_init = ExprId('EDX_init', 32)

EIP

miasm.arch.x86.regs.EIP = ExprId('EIP', 32)

ES

miasm.arch.x86.regs.ES = ExprId(reg_es, size=16)

ESI

list miasm.arch.x86.regs.ESI = regs32_expr[6]

ESI_init

miasm.arch.x86.regs.ESI_init = ExprId('ESI_init', 32)

ESP

list miasm.arch.x86.regs.ESP = regs32_expr[4]

ESP_init

miasm.arch.x86.regs.ESP_init = ExprId('ESP_init', 32)

exception_flags

miasm.arch.x86.regs.exception_flags = ExprId('exception_flags', 32)

float_address

miasm.arch.x86.regs.float_address = ExprId(reg_float_address, 32)

float_c0

miasm.arch.x86.regs.float_c0 = ExprId(reg_float_c0, size=1)

float_c1

miasm.arch.x86.regs.float_c1 = ExprId(reg_float_c1, size=1)

float_c2

miasm.arch.x86.regs.float_c2 = ExprId(reg_float_c2, size=1)

float_c3

miasm.arch.x86.regs.float_c3 = ExprId(reg_float_c3, size=1)

float_control

miasm.arch.x86.regs.float_control = ExprId(reg_float_control, 16)

float_cs

miasm.arch.x86.regs.float_cs = ExprId(reg_float_cs, size=16)

float_ds

miasm.arch.x86.regs.float_ds = ExprId(reg_float_ds, size=16)

float_eip

miasm.arch.x86.regs.float_eip = ExprId(reg_float_eip, 32)

float_list

list miasm.arch.x86.regs.float_list

Initial value:

=  [float_st0, float_st1, float_st2, float_st3,
              float_st4, float_st5, float_st6, float_st7]

float_replace

dictionary miasm.arch.x86.regs.float_replace = {fltregs32_expr[i]: float_list[i] for i in range(8)}

float_st0

miasm.arch.x86.regs.float_st0 = ExprId("float_st0", 64)

float_st1

miasm.arch.x86.regs.float_st1 = ExprId("float_st1", 64)

float_st2

miasm.arch.x86.regs.float_st2 = ExprId("float_st2", 64)

float_st3

miasm.arch.x86.regs.float_st3 = ExprId("float_st3", 64)

float_st4

miasm.arch.x86.regs.float_st4 = ExprId("float_st4", 64)

float_st5

miasm.arch.x86.regs.float_st5 = ExprId("float_st5", 64)

float_st6

miasm.arch.x86.regs.float_st6 = ExprId("float_st6", 64)

float_st7

miasm.arch.x86.regs.float_st7 = ExprId("float_st7", 64)

float_stack_ptr

miasm.arch.x86.regs.float_stack_ptr = ExprId(reg_float_stack_ptr, size=3)

fltregs

miasm.arch.x86.regs.fltregs = reg_info(fltregs32_str, fltregs32_expr)

fltregs32_expr

list miasm.arch.x86.regs.fltregs32_expr = [ExprId(x, 64) for x in fltregs32_str]

fltregs32_str

list miasm.arch.x86.regs.fltregs32_str = ["ST(%d)" % i for i in range(8)]

FS

miasm.arch.x86.regs.FS = ExprId(reg_fs, size=16)

gpregs08

miasm.arch.x86.regs.gpregs08 = reg_info(regs08_str, regs08_expr)

gpregs08_64

miasm.arch.x86.regs.gpregs08_64 = reg_info(regs08_64_str, regs08_64_expr)

gpregs16

miasm.arch.x86.regs.gpregs16 = reg_info(regs16_str, regs16_expr)

gpregs32

miasm.arch.x86.regs.gpregs32 = reg_info(regs32_str, regs32_expr)

gpregs64

miasm.arch.x86.regs.gpregs64 = reg_info(regs64_str, regs64_expr)

gpregs_bnd

miasm.arch.x86.regs.gpregs_bnd = reg_info(regs_bnd_str, regs_bnd_expr)

gpregs_mm

miasm.arch.x86.regs.gpregs_mm = reg_info(regs_mm_str, regs_mm_expr)

gpregs_xmm

miasm.arch.x86.regs.gpregs_xmm = reg_info(regs_xmm_str, regs_xmm_expr)

GS

miasm.arch.x86.regs.GS = ExprId(reg_gs, size=16)

i_d

miasm.arch.x86.regs.i_d = ExprId(reg_id, size=1)

i_f

miasm.arch.x86.regs.i_f = ExprId(reg_if, size=1)

interrupt_num

miasm.arch.x86.regs.interrupt_num = ExprId('interrupt_num', 8)

iopl

miasm.arch.x86.regs.iopl = ExprId(reg_iopl, size=2)

IP

miasm.arch.x86.regs.IP = ExprId('IP', 16)

mm0

miasm.arch.x86.regs.mm0 = ExprId(reg_mm0, 64)

mm1

miasm.arch.x86.regs.mm1 = ExprId(reg_mm1, 64)

mm2

miasm.arch.x86.regs.mm2 = ExprId(reg_mm2, 64)

mm3

miasm.arch.x86.regs.mm3 = ExprId(reg_mm3, 64)

mm4

miasm.arch.x86.regs.mm4 = ExprId(reg_mm4, 64)

mm5

miasm.arch.x86.regs.mm5 = ExprId(reg_mm5, 64)

mm6

miasm.arch.x86.regs.mm6 = ExprId(reg_mm6, 64)

mm7

miasm.arch.x86.regs.mm7 = ExprId(reg_mm7, 64)

mRAX

dictionary miasm.arch.x86.regs.mRAX = {16: AX, 32: EAX, 64: RAX}

mRBP

dictionary miasm.arch.x86.regs.mRBP = {16: BP, 32: EBP, 64: RBP}

mRBX

dictionary miasm.arch.x86.regs.mRBX = {16: BX, 32: EBX, 64: RBX}

mRCX

dictionary miasm.arch.x86.regs.mRCX = {16: CX, 32: ECX, 64: RCX}

mRDI

dictionary miasm.arch.x86.regs.mRDI = {16: DI, 32: EDI, 64: RDI}

mRDX

dictionary miasm.arch.x86.regs.mRDX = {16: DX, 32: EDX, 64: RDX}

mRIP

dictionary miasm.arch.x86.regs.mRIP = {16: IP, 32: EIP, 64: RIP}

mRSI

dictionary miasm.arch.x86.regs.mRSI = {16: SI, 32: ESI, 64: RSI}

mRSP

dictionary miasm.arch.x86.regs.mRSP = {16: SP, 32: ESP, 64: RSP}

nf

miasm.arch.x86.regs.nf = ExprId(reg_nf, size=1)

nt

miasm.arch.x86.regs.nt = ExprId(reg_nt, size=1)

of

miasm.arch.x86.regs.of = ExprId(reg_of, size=1)

pf

miasm.arch.x86.regs.pf = ExprId(reg_pf, size=1)

r08_eax

miasm.arch.x86.regs.r08_eax = reg_info([regs08_str[0]], [regs08_expr[0]])

r08_ecx

miasm.arch.x86.regs.r08_ecx = reg_info([regs08_str[1]], [regs08_expr[1]])

R10

list miasm.arch.x86.regs.R10 = regs64_expr[10]

R10B

list miasm.arch.x86.regs.R10B = regs08_expr[10]

R10D

list miasm.arch.x86.regs.R10D = regs32_expr[10]

R10W

list miasm.arch.x86.regs.R10W = regs16_expr[10]

R11

list miasm.arch.x86.regs.R11 = regs64_expr[11]

R11B

list miasm.arch.x86.regs.R11B = regs08_expr[11]

R11D

list miasm.arch.x86.regs.R11D = regs32_expr[11]

R11W

list miasm.arch.x86.regs.R11W = regs16_expr[11]

R12

list miasm.arch.x86.regs.R12 = regs64_expr[12]

R12B

list miasm.arch.x86.regs.R12B = regs08_expr[12]

R12D

list miasm.arch.x86.regs.R12D = regs32_expr[12]

R12W

list miasm.arch.x86.regs.R12W = regs16_expr[12]

R13

list miasm.arch.x86.regs.R13 = regs64_expr[13]

R13B

list miasm.arch.x86.regs.R13B = regs08_expr[13]

R13D

list miasm.arch.x86.regs.R13D = regs32_expr[13]

R13W

list miasm.arch.x86.regs.R13W = regs16_expr[13]

R14

list miasm.arch.x86.regs.R14 = regs64_expr[14]

R14B

list miasm.arch.x86.regs.R14B = regs08_expr[14]

R14D

list miasm.arch.x86.regs.R14D = regs32_expr[14]

R14W

list miasm.arch.x86.regs.R14W = regs16_expr[14]

R15

list miasm.arch.x86.regs.R15 = regs64_expr[15]

R15B

list miasm.arch.x86.regs.R15B = regs08_expr[15]

R15D

list miasm.arch.x86.regs.R15D = regs32_expr[15]

R15W

list miasm.arch.x86.regs.R15W = regs16_expr[15]

r16_eax

miasm.arch.x86.regs.r16_eax = reg_info([regs16_str[0]], [regs16_expr[0]])

r16_edx

miasm.arch.x86.regs.r16_edx = reg_info([regs16_str[2]], [regs16_expr[2]])

r32_eax

miasm.arch.x86.regs.r32_eax = reg_info([regs32_str[0]], [regs32_expr[0]])

r64_eax

miasm.arch.x86.regs.r64_eax = reg_info([regs64_str[0]], [regs64_expr[0]])

R8

list miasm.arch.x86.regs.R8 = regs64_expr[8]

R8B

list miasm.arch.x86.regs.R8B = regs08_expr[8]

R8D

list miasm.arch.x86.regs.R8D = regs32_expr[8]

R8W

list miasm.arch.x86.regs.R8W = regs16_expr[8]

R9

list miasm.arch.x86.regs.R9 = regs64_expr[9]

R9B

list miasm.arch.x86.regs.R9B = regs08_expr[9]

R9D

list miasm.arch.x86.regs.R9D = regs32_expr[9]

R9W

list miasm.arch.x86.regs.R9W = regs16_expr[9]

r_cs_all

miasm.arch.x86.regs.r_cs_all

Initial value:

=  reg_info(['CS'],
                    [ExprId('CS', 16)])

r_ds_all

miasm.arch.x86.regs.r_ds_all

Initial value:

=  reg_info(['DS'],
                    [ExprId('DS', 16)])

r_eax_all

miasm.arch.x86.regs.r_eax_all

Initial value:

=  reg_info(
    [regs08_str[0], regs16_str[0], regs32_str[0], regs64_str[0]],
    [regs08_expr[0], regs16_expr[0], regs32_expr[0], regs64_expr[0]])

r_edx_all

miasm.arch.x86.regs.r_edx_all

Initial value:

=  reg_info(
    [regs08_str[2], regs16_str[2], regs32_str[2], regs64_str[2]],
    [regs08_expr[2], regs16_expr[2], regs32_expr[2], regs64_expr[2]])

r_es_all

miasm.arch.x86.regs.r_es_all

Initial value:

=  reg_info(['ES'],
                    [ExprId('ES', 16)])

r_fs_all

miasm.arch.x86.regs.r_fs_all

Initial value:

=  reg_info(['FS'],
                    [ExprId('FS', 16)])

r_gs_all

miasm.arch.x86.regs.r_gs_all

Initial value:

=  reg_info(['GS'],
                    [ExprId('GS', 16)])

r_ss_all

miasm.arch.x86.regs.r_ss_all

Initial value:

=  reg_info(['SS'],
                    [ExprId('SS', 16)])

r_st_all

miasm.arch.x86.regs.r_st_all

Initial value:

=  reg_info(['ST'],
                    [ExprId('ST', 64)])

RAX

list miasm.arch.x86.regs.RAX = regs64_expr[0]

RAX_init

miasm.arch.x86.regs.RAX_init = ExprId('RAX_init', 64)

RBP

list miasm.arch.x86.regs.RBP = regs64_expr[5]

RBP_init

miasm.arch.x86.regs.RBP_init = ExprId('RBP_init', 64)

RBX

list miasm.arch.x86.regs.RBX = regs64_expr[3]

RBX_init

miasm.arch.x86.regs.RBX_init = ExprId('RBX_init', 64)

RCX

list miasm.arch.x86.regs.RCX = regs64_expr[1]

RCX_init

miasm.arch.x86.regs.RCX_init = ExprId('RCX_init', 64)

RDI

list miasm.arch.x86.regs.RDI = regs64_expr[7]

RDI_init

miasm.arch.x86.regs.RDI_init = ExprId('RDI_init', 64)

RDX

list miasm.arch.x86.regs.RDX = regs64_expr[2]

RDX_init

miasm.arch.x86.regs.RDX_init = ExprId('RDX_init', 64)

reg_ac

string miasm.arch.x86.regs.reg_ac = 'ac'

reg_af

string miasm.arch.x86.regs.reg_af = 'af'

reg_cf

string miasm.arch.x86.regs.reg_cf = 'cf'

reg_cr0

string miasm.arch.x86.regs.reg_cr0 = 'CR0'

reg_cr1

string miasm.arch.x86.regs.reg_cr1 = 'CR1'

reg_cr2

string miasm.arch.x86.regs.reg_cr2 = 'CR2'

reg_cr3

string miasm.arch.x86.regs.reg_cr3 = 'CR3'

reg_cr4

string miasm.arch.x86.regs.reg_cr4 = 'CR4'

reg_cr5

string miasm.arch.x86.regs.reg_cr5 = 'CR5'

reg_cr6

string miasm.arch.x86.regs.reg_cr6 = 'CR6'

reg_cr7

string miasm.arch.x86.regs.reg_cr7 = 'CR7'

reg_cs

string miasm.arch.x86.regs.reg_cs = "CS"

reg_df

string miasm.arch.x86.regs.reg_df = 'df'

reg_dr0

string miasm.arch.x86.regs.reg_dr0 = 'DR0'

reg_dr1

string miasm.arch.x86.regs.reg_dr1 = 'DR1'

reg_dr2

string miasm.arch.x86.regs.reg_dr2 = 'DR2'

reg_dr3

string miasm.arch.x86.regs.reg_dr3 = 'DR3'

reg_dr4

string miasm.arch.x86.regs.reg_dr4 = 'DR4'

reg_dr5

string miasm.arch.x86.regs.reg_dr5 = 'DR5'

reg_dr6

string miasm.arch.x86.regs.reg_dr6 = 'DR6'

reg_dr7

string miasm.arch.x86.regs.reg_dr7 = 'DR7'

reg_ds

string miasm.arch.x86.regs.reg_ds = "DS"

reg_es

string miasm.arch.x86.regs.reg_es = "ES"

reg_float_address

string miasm.arch.x86.regs.reg_float_address = 'reg_float_address'

reg_float_c0

string miasm.arch.x86.regs.reg_float_c0 = 'float_c0'

reg_float_c1

string miasm.arch.x86.regs.reg_float_c1 = 'float_c1'

reg_float_c2

string miasm.arch.x86.regs.reg_float_c2 = 'float_c2'

reg_float_c3

string miasm.arch.x86.regs.reg_float_c3 = 'float_c3'

reg_float_control

string miasm.arch.x86.regs.reg_float_control = 'reg_float_control'

reg_float_cs

string miasm.arch.x86.regs.reg_float_cs = 'reg_float_cs'

reg_float_ds

string miasm.arch.x86.regs.reg_float_ds = 'reg_float_ds'

reg_float_eip

string miasm.arch.x86.regs.reg_float_eip = 'reg_float_eip'

reg_float_stack_ptr

string miasm.arch.x86.regs.reg_float_stack_ptr = "float_stack_ptr"

reg_fs

string miasm.arch.x86.regs.reg_fs = "FS"

reg_gs

string miasm.arch.x86.regs.reg_gs = "GS"

reg_id

string miasm.arch.x86.regs.reg_id = 'i_d'

reg_if

string miasm.arch.x86.regs.reg_if = 'i_f'

reg_iopl

string miasm.arch.x86.regs.reg_iopl = 'iopl_f'

reg_mm0

string miasm.arch.x86.regs.reg_mm0 = 'MM0'

reg_mm1

string miasm.arch.x86.regs.reg_mm1 = 'MM1'

reg_mm2

string miasm.arch.x86.regs.reg_mm2 = 'MM2'

reg_mm3

string miasm.arch.x86.regs.reg_mm3 = 'MM3'

reg_mm4

string miasm.arch.x86.regs.reg_mm4 = 'MM4'

reg_mm5

string miasm.arch.x86.regs.reg_mm5 = 'MM5'

reg_mm6

string miasm.arch.x86.regs.reg_mm6 = 'MM6'

reg_mm7

string miasm.arch.x86.regs.reg_mm7 = 'MM7'

reg_nf

string miasm.arch.x86.regs.reg_nf = 'nf'

reg_nt

string miasm.arch.x86.regs.reg_nt = 'nt'

reg_of

string miasm.arch.x86.regs.reg_of = 'of'

reg_pf

string miasm.arch.x86.regs.reg_pf = 'pf'

reg_rf

string miasm.arch.x86.regs.reg_rf = 'rf'

reg_ss

string miasm.arch.x86.regs.reg_ss = "SS"

reg_tf

string miasm.arch.x86.regs.reg_tf = 'tf'

reg_tsc

string miasm.arch.x86.regs.reg_tsc = "tsc"

reg_vif

string miasm.arch.x86.regs.reg_vif = 'vif'

reg_vip

string miasm.arch.x86.regs.reg_vip = 'vip'

reg_vm

string miasm.arch.x86.regs.reg_vm = 'vm'

reg_zf

string miasm.arch.x86.regs.reg_zf = 'zf'

regs08_64_expr

list miasm.arch.x86.regs.regs08_64_expr = [ExprId(x, 8) for x in regs08_64_str]

regs08_64_str

list miasm.arch.x86.regs.regs08_64_str = ["AL", "CL", "DL", "BL", "SPL", "BPL", "SIL", "DIL"] + \

regs08_expr

list miasm.arch.x86.regs.regs08_expr = [ExprId(x, 8) for x in regs08_str]

regs08_str

list miasm.arch.x86.regs.regs08_str = ["AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"] + \

regs16_expr

list miasm.arch.x86.regs.regs16_expr = [ExprId(x, 16) for x in regs16_str]

regs16_str

list miasm.arch.x86.regs.regs16_str = ["AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"] + \

regs32_expr

list miasm.arch.x86.regs.regs32_expr = [ExprId(x, 32) for x in regs32_str]

regs32_str

list miasm.arch.x86.regs.regs32_str = ["EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"] + \

regs64_expr

list miasm.arch.x86.regs.regs64_expr = [ExprId(x, 64) for x in regs64_str]

regs64_str

list miasm.arch.x86.regs.regs64_str

Initial value:

=  ["RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI",
              "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
              "RIP"]

regs_bnd_expr

list miasm.arch.x86.regs.regs_bnd_expr = [ExprId(x, 128) for x in regs_bnd_str]

regs_bnd_str

list miasm.arch.x86.regs.regs_bnd_str = ["BND%d" % i for i in range(4)]

regs_flt_expr

list miasm.arch.x86.regs.regs_flt_expr

Initial value:

=  [float_st0, float_st1, float_st2, float_st3,
                 float_st4, float_st5, float_st6, float_st7,
                 ]

regs_init

dictionary miasm.arch.x86.regs.regs_init = {}

regs_mm_expr

list miasm.arch.x86.regs.regs_mm_expr = [ExprId(x, 64) for x in regs_mm_str]

regs_mm_str

list miasm.arch.x86.regs.regs_mm_str = ["MM%d" % i for i in range(16)]

regs_xmm_expr

list miasm.arch.x86.regs.regs_xmm_expr = [ExprId(x, 128) for x in regs_xmm_str]

regs_xmm_str

list miasm.arch.x86.regs.regs_xmm_str = ["XMM%d" % i for i in range(16)]

rf

miasm.arch.x86.regs.rf = ExprId(reg_rf, size=1)

RIP

miasm.arch.x86.regs.RIP = ExprId('RIP', 64)

RSI

list miasm.arch.x86.regs.RSI = regs64_expr[6]

RSI_init

miasm.arch.x86.regs.RSI_init = ExprId('RSI_init', 64)

RSP

list miasm.arch.x86.regs.RSP = regs64_expr[4]

RSP_init

miasm.arch.x86.regs.RSP_init = ExprId('RSP_init', 64)

segmreg

miasm.arch.x86.regs.segmreg = reg_info(selectr_str, selectr_expr)

selectr_expr

list miasm.arch.x86.regs.selectr_expr = [ExprId(x, 16) for x in selectr_str]

selectr_str

list miasm.arch.x86.regs.selectr_str = ["ES", "CS", "SS", "DS", "FS", "GS"]

SI

list miasm.arch.x86.regs.SI = regs16_expr[6]

SIL

list miasm.arch.x86.regs.SIL = regs08_64_expr[6]

SP

list miasm.arch.x86.regs.SP = regs16_expr[4]

SPL

list miasm.arch.x86.regs.SPL = regs08_64_expr[4]

SS

miasm.arch.x86.regs.SS = ExprId(reg_ss, size=16)

tf

miasm.arch.x86.regs.tf = ExprId(reg_tf, size=1)

tsc

miasm.arch.x86.regs.tsc = ExprId(reg_tsc, size=64)

vif

miasm.arch.x86.regs.vif = ExprId(reg_vif, size=1)

vip

miasm.arch.x86.regs.vip = ExprId(reg_vip, size=1)

vm

miasm.arch.x86.regs.vm = ExprId(reg_vm, size=1)

XMM0

list miasm.arch.x86.regs.XMM0 = regs_xmm_expr[0]

XMM1

list miasm.arch.x86.regs.XMM1 = regs_xmm_expr[1]

XMM10

list miasm.arch.x86.regs.XMM10 = regs_xmm_expr[10]

XMM11

list miasm.arch.x86.regs.XMM11 = regs_xmm_expr[11]

XMM12

list miasm.arch.x86.regs.XMM12 = regs_xmm_expr[12]

XMM13

list miasm.arch.x86.regs.XMM13 = regs_xmm_expr[13]

XMM14

list miasm.arch.x86.regs.XMM14 = regs_xmm_expr[14]

XMM15

list miasm.arch.x86.regs.XMM15 = regs_xmm_expr[15]

XMM2

list miasm.arch.x86.regs.XMM2 = regs_xmm_expr[2]

XMM3

list miasm.arch.x86.regs.XMM3 = regs_xmm_expr[3]

XMM4

list miasm.arch.x86.regs.XMM4 = regs_xmm_expr[4]

XMM5

list miasm.arch.x86.regs.XMM5 = regs_xmm_expr[5]

XMM6

list miasm.arch.x86.regs.XMM6 = regs_xmm_expr[6]

XMM7

list miasm.arch.x86.regs.XMM7 = regs_xmm_expr[7]

XMM8

list miasm.arch.x86.regs.XMM8 = regs_xmm_expr[8]

XMM9

list miasm.arch.x86.regs.XMM9 = regs_xmm_expr[9]

zf

miasm.arch.x86.regs.zf = ExprId(reg_zf, size=1)