miasm
Reverse engineering framework
miasm.arch.ppc.regs Namespace Reference

Variables

 exception_flags = ExprId('exception_flags', 32)
 
 spr_access = ExprId('spr_access', 32)
 
 reserve = ExprId('reserve', 1)
 
 reserve_address = ExprId('reserve_address', 32)
 
int SPR_ACCESS_IS_WRITE = 0x80000000
 
int SPR_ACCESS_SPR_MASK = 0x000003FF
 
int SPR_ACCESS_SPR_OFF = 0
 
int SPR_ACCESS_GPR_MASK = 0x0001F000
 
int SPR_ACCESS_GPR_OFF = 12
 
list gpregs_str = ["R%d" % i for i in range(32)]
 
 gpregs_expr
 
 gpregs_init
 
 gpregs
 
list crfregs_str = ["CR%d" % i for i in range(8)]
 
 crfregs_expr
 
 crfregs_init
 
 crfregs
 
list crfbitregs_str
 
 crfbitregs_expr
 
 crfbitregs_init
 
 crfbitregs
 
list xerbitregs_str = ["XER_%s" % field for field in ['SO', 'OV', 'CA'] ]
 
 xerbitregs_expr
 
 xerbitregs_init
 
 xerbitregs
 
list xerbcreg_str = ["XER_BC"]
 
 xerbcreg_expr
 
 xerbcreg_init
 
 xerbcreg
 
list otherregs_str = ["PC", "CTR", "LR", "FPSCR", "VRSAVE", "VSCR" ]
 
 otherregs_expr
 
 otherregs_init
 
 otherregs
 
tuple superregs_str
 
 superregs_expr
 
 superregs_init
 
 superregs
 
tuple mmuregs_str
 
 mmuregs_expr
 
 mmuregs_init
 
 mmuregs
 
tuple floatregs_str = (["FPR%d" % i for i in range(32)])
 
 floatregs_expr
 
 floatregs_init
 
 floatregs
 
tuple vexregs_str = (["VR%d" % i for i in range(32)])
 
 vexregs_expr
 
 vexregs_init
 
 vexregs
 
list regs_flt_expr = []
 
tuple all_regs_ids
 
 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]
 
tuple all_regs_ids_no_alias = all_regs_ids[:]
 
dictionary regs_init = {}
 

Variable Documentation

◆ all_regs_ids

tuple miasm.arch.ppc.regs.all_regs_ids
Initial value:
1 = (gpregs_expr + crfbitregs_expr + xerbitregs_expr +
2  xerbcreg_expr + otherregs_expr + superregs_expr + mmuregs_expr + floatregs_expr + vexregs_expr +
3  [ exception_flags, spr_access, reserve, reserve_address ])

◆ all_regs_ids_byname

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

◆ all_regs_ids_init

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

◆ all_regs_ids_no_alias

tuple miasm.arch.ppc.regs.all_regs_ids_no_alias = all_regs_ids[:]

◆ crfbitregs

miasm.arch.ppc.regs.crfbitregs

◆ crfbitregs_expr

miasm.arch.ppc.regs.crfbitregs_expr

◆ crfbitregs_init

miasm.arch.ppc.regs.crfbitregs_init

◆ crfbitregs_str

list miasm.arch.ppc.regs.crfbitregs_str
Initial value:
1 = ["CR%d_%s" % (i, flag) for i in range(8)
2  for flag in ['LT', 'GT', 'EQ', 'SO'] ]

◆ crfregs

miasm.arch.ppc.regs.crfregs

◆ crfregs_expr

miasm.arch.ppc.regs.crfregs_expr

◆ crfregs_init

miasm.arch.ppc.regs.crfregs_init

◆ crfregs_str

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

◆ exception_flags

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

◆ floatregs

miasm.arch.ppc.regs.floatregs

◆ floatregs_expr

miasm.arch.ppc.regs.floatregs_expr

◆ floatregs_init

miasm.arch.ppc.regs.floatregs_init

◆ floatregs_str

tuple miasm.arch.ppc.regs.floatregs_str = (["FPR%d" % i for i in range(32)])

◆ gpregs

miasm.arch.ppc.regs.gpregs

◆ gpregs_expr

miasm.arch.ppc.regs.gpregs_expr

◆ gpregs_init

miasm.arch.ppc.regs.gpregs_init

◆ gpregs_str

list miasm.arch.ppc.regs.gpregs_str = ["R%d" % i for i in range(32)]

◆ mmuregs

miasm.arch.ppc.regs.mmuregs

◆ mmuregs_expr

miasm.arch.ppc.regs.mmuregs_expr

◆ mmuregs_init

miasm.arch.ppc.regs.mmuregs_init

◆ mmuregs_str

tuple miasm.arch.ppc.regs.mmuregs_str
Initial value:
1 = (["SR%d" % i for i in range(16)] +
2  ["IBAT%dU" % i for i in range(4)] +
3  ["IBAT%dL" % i for i in range(4)] +
4  ["DBAT%dU" % i for i in range(4)] +
5  ["DBAT%dL" % i for i in range(4)] +
6  ["SDR1"])

◆ otherregs

miasm.arch.ppc.regs.otherregs

◆ otherregs_expr

miasm.arch.ppc.regs.otherregs_expr

◆ otherregs_init

miasm.arch.ppc.regs.otherregs_init

◆ otherregs_str

list miasm.arch.ppc.regs.otherregs_str = ["PC", "CTR", "LR", "FPSCR", "VRSAVE", "VSCR" ]

◆ regs_flt_expr

list miasm.arch.ppc.regs.regs_flt_expr = []

◆ regs_init

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

◆ reserve

miasm.arch.ppc.regs.reserve = ExprId('reserve', 1)

◆ reserve_address

miasm.arch.ppc.regs.reserve_address = ExprId('reserve_address', 32)

◆ spr_access

miasm.arch.ppc.regs.spr_access = ExprId('spr_access', 32)

◆ SPR_ACCESS_GPR_MASK

int miasm.arch.ppc.regs.SPR_ACCESS_GPR_MASK = 0x0001F000

◆ SPR_ACCESS_GPR_OFF

int miasm.arch.ppc.regs.SPR_ACCESS_GPR_OFF = 12

◆ SPR_ACCESS_IS_WRITE

int miasm.arch.ppc.regs.SPR_ACCESS_IS_WRITE = 0x80000000

◆ SPR_ACCESS_SPR_MASK

int miasm.arch.ppc.regs.SPR_ACCESS_SPR_MASK = 0x000003FF

◆ SPR_ACCESS_SPR_OFF

int miasm.arch.ppc.regs.SPR_ACCESS_SPR_OFF = 0

◆ superregs

miasm.arch.ppc.regs.superregs

◆ superregs_expr

miasm.arch.ppc.regs.superregs_expr

◆ superregs_init

miasm.arch.ppc.regs.superregs_init

◆ superregs_str

tuple miasm.arch.ppc.regs.superregs_str
Initial value:
1 = (["SPRG%d" % i for i in range(4)] +
2  ["SRR%d" % i for i in range(2)] +
3  ["DAR", "DSISR", "MSR", "PIR", "PVR",
4  "DEC", "TBL", "TBU"])

◆ vexregs

miasm.arch.ppc.regs.vexregs

◆ vexregs_expr

miasm.arch.ppc.regs.vexregs_expr

◆ vexregs_init

miasm.arch.ppc.regs.vexregs_init

◆ vexregs_str

tuple miasm.arch.ppc.regs.vexregs_str = (["VR%d" % i for i in range(32)])

◆ xerbcreg

miasm.arch.ppc.regs.xerbcreg

◆ xerbcreg_expr

miasm.arch.ppc.regs.xerbcreg_expr

◆ xerbcreg_init

miasm.arch.ppc.regs.xerbcreg_init

◆ xerbcreg_str

list miasm.arch.ppc.regs.xerbcreg_str = ["XER_BC"]

◆ xerbitregs

miasm.arch.ppc.regs.xerbitregs

◆ xerbitregs_expr

miasm.arch.ppc.regs.xerbitregs_expr

◆ xerbitregs_init

miasm.arch.ppc.regs.xerbitregs_init

◆ xerbitregs_str

list miasm.arch.ppc.regs.xerbitregs_str = ["XER_%s" % field for field in ['SO', 'OV', 'CA'] ]
range
Definition: range.py:1