openpower.decoder.isa package

Submodules

openpower.decoder.isa.all module

class openpower.decoder.isa.all.ISA(*args, **kwargs)

Bases: openpower.decoder.isa.caller.ISACaller, openpower.decoder.isa.bcd.bcd, openpower.decoder.isa.branch.branch, openpower.decoder.isa.comparefixed.comparefixed, openpower.decoder.isa.condition.condition, openpower.decoder.isa.fixedarith.fixedarith, openpower.decoder.isa.fixedldstcache.fixedldstcache, openpower.decoder.isa.fixedload.fixedload, openpower.decoder.isa.fixedlogical.fixedlogical, openpower.decoder.isa.fixedshift.fixedshift, openpower.decoder.isa.fixedstore.fixedstore, openpower.decoder.isa.fixedtrap.fixedtrap, openpower.decoder.isa.simplev.simplev, openpower.decoder.isa.sprset.sprset, openpower.decoder.isa.stringldst.stringldst, openpower.decoder.isa.system.system

openpower.decoder.isa.bcd module

class openpower.decoder.isa.bcd.bcd

Bases: object

bcd_instrs = {'addg6s': instruction_info(func=<function bcd.op_addg6s>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB']]), 'cbcdtd': instruction_info(func=<function bcd.op_cbcdtd>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', ''], 'RS']), 'cdtbcd': instruction_info(func=<function bcd.op_cdtbcd>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', ''], 'RS'])}

op_addg6s(RA, RB)

op_cbcdtd(RA, RS)

op_cdtbcd(RA, RS)

openpower.decoder.isa.branch module

class openpower.decoder.isa.branch.branch

Bases: object

branch_instrs = {'b': instruction_info(func=<function branch.op_b>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['LR']), special_regs=OrderedSet(['LR']), op_fields=OrderedSet(['AA', 'LI', 'LK']), form='I', asmregs=[['target_addr'], '(AA=0', 'LK=0)']), 'ba': instruction_info(func=<function branch.op_ba>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['LR']), special_regs=OrderedSet(['LR']), op_fields=OrderedSet(['AA', 'LI', 'LK']), form='I', asmregs=[['target_addr'], '(AA=1', 'LK=0)']), 'bc': instruction_info(func=<function branch.op_bc>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'AA', 'BD', 'LK']), form='B', asmregs=[['BO', 'BI', 'target_addr'], '(AA=0', 'LK=0)']), 'bca': instruction_info(func=<function branch.op_bca>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'AA', 'BD', 'LK']), form='B', asmregs=[['BO', 'BI', 'target_addr'], '(AA=1', 'LK=0)']), 'bcctr': instruction_info(func=<function branch.op_bcctr>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR', 'CTR', 'LR']), special_regs=OrderedSet(['CR', 'CTR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'LK']), form='XL', asmregs=[['BO', 'BI', 'BH'], '(LK=0)']), 'bcctrl': instruction_info(func=<function branch.op_bcctrl>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR', 'CTR', 'LR']), special_regs=OrderedSet(['CR', 'CTR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'LK']), form='XL', asmregs=[['BO', 'BI', 'BH'], '(LK=1)']), 'bcl': instruction_info(func=<function branch.op_bcl>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'AA', 'BD', 'LK']), form='B', asmregs=[['BO', 'BI', 'target_addr'], '(AA=0', 'LK=1)']), 'bcla': instruction_info(func=<function branch.op_bcla>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'AA', 'BD', 'LK']), form='B', asmregs=[['BO', 'BI', 'target_addr'], '(AA=1', 'LK=1)']), 'bclr': instruction_info(func=<function branch.op_bclr>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'LK']), form='XL', asmregs=[['BO', 'BI', 'BH'], '(LK=0)']), 'bclrl': instruction_info(func=<function branch.op_bclrl>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'LK']), form='XL', asmregs=[['BO', 'BI', 'BH'], '(LK=1)']), 'bctar': instruction_info(func=<function branch.op_bctar>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'TAR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'TAR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'LK']), form='XL', asmregs=[['BO', 'BI', 'BH'], '(LK=0)']), 'bctarl': instruction_info(func=<function branch.op_bctarl>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CTR', 'CR', 'TAR', 'LR']), special_regs=OrderedSet(['CTR', 'CR', 'TAR', 'LR']), op_fields=OrderedSet(['BO', 'BI', 'LK']), form='XL', asmregs=[['BO', 'BI', 'BH'], '(LK=1)']), 'bl': instruction_info(func=<function branch.op_bl>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['LR']), special_regs=OrderedSet(['LR']), op_fields=OrderedSet(['AA', 'LI', 'LK']), form='I', asmregs=[['target_addr'], '(AA=0', 'LK=1)']), 'bla': instruction_info(func=<function branch.op_bla>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['LR']), special_regs=OrderedSet(['LR']), op_fields=OrderedSet(['AA', 'LI', 'LK']), form='I', asmregs=[['target_addr'], '(AA=1', 'LK=1)'])}

op_b(LR)

op_ba(LR)

op_bc(CTR, CR, LR)

op_bca(CTR, CR, LR)

op_bcctr(CR, CTR, LR)

op_bcctrl(CR, CTR, LR)

op_bcl(CTR, CR, LR)

op_bcla(CTR, CR, LR)

op_bclr(CTR, CR, LR)

op_bclrl(CTR, CR, LR)

op_bctar(CTR, CR, TAR, LR)

op_bctarl(CTR, CR, TAR, LR)

op_bl(LR)

op_bla(LR)

openpower.decoder.isa.caller module

core of the python-based POWER9 simulator

this is part of a cycle-accurate POWER9 simulator. its primary purpose is not speed, it is for both learning and educational purposes, as well as a method of verifying the HDL.

related bugs:

• https://bugs.libre-soc.org/show_bug.cgi?id=424

class openpower.decoder.isa.caller.CRFields(init=0)

Bases: object

EQ = 2

FE = 2

FG = 1

FL = 0

FU = 3

GT = 1

LT = 0

SO = 3

class openpower.decoder.isa.caller.GPR(decoder, isacaller, svstate, regfile)

Bases: dict

dump()

getz(rnum)

set_form(form)

class openpower.decoder.isa.caller.ISACaller(decoder2, regfile, initial_sprs=None, initial_cr=0, initial_mem=None, initial_msr=0, initial_svstate=0, initial_insns=None, respect_pc=False, disassembly=None, initial_pc=0, bigendian=False, mmu=False, icachemmu=False)

Bases: object

TRAP(trap_addr=1792, trap_bit=46)

call(name)

call(opcode) - the primary execution point for instructions

execute_one()

execute one instruction

get_assembly_name()

get_spr_msb()

handle_carry_(inputs, outputs, already_done)

handle_comparison(outputs, cr_idx=0)

handle_overflow(inputs, outputs, div_overflow)

memassign(ea, sz, val)

prep_namespace(formname, op_fields)

set_pc(pc_val)

setup_one()

set up one instruction

svp64_reset_loop()

update_pc_next()

class openpower.decoder.isa.caller.PC(pc_init=0)

Bases: object

update(namespace, is_svp64)

updates the program counter (PC) by 4 if v3.0B mode or 8 if SVP64

update_nia(is_svp64)

class openpower.decoder.isa.caller.SPR(dec2, initial_sprs={})

Bases: dict

class openpower.decoder.isa.caller.SVP64PrefixFields

Bases: object

class openpower.decoder.isa.caller.SVP64RMFields(init=0)

Bases: object

class openpower.decoder.isa.caller.SVP64State(init=0)

Bases: object

openpower.decoder.isa.caller.create_args(reglist, extra=None)

openpower.decoder.isa.caller.get_pdecode_cr_out(dec2, name)

openpower.decoder.isa.caller.get_pdecode_idx_in(dec2, name)

openpower.decoder.isa.caller.get_pdecode_idx_out(dec2, name)

openpower.decoder.isa.caller.get_pdecode_idx_out2(dec2, name)

openpower.decoder.isa.caller.get_predcr(crl, mask, vl)

openpower.decoder.isa.caller.get_predint(gpr, mask)

openpower.decoder.isa.caller.inject()

Decorator factory.

this decorator will “inject” variables into the function’s namespace, from the dictionary in self.namespace. it therefore becomes possible to make it look like a whole stack of variables which would otherwise need “self.” inserted in front of them (and for those variables to be added to the instance) “appear” in the function.

“self.namespace[‘SI’]” for example becomes accessible as just “SI” but only inside the function, when decorated.

class openpower.decoder.isa.caller.instruction_info(func, read_regs, uninit_regs, write_regs, special_regs, op_fields, form, asmregs)

Bases: tuple

asmregs

Alias for field number 7

form

Alias for field number 6

func

Alias for field number 0

op_fields

Alias for field number 5

read_regs

Alias for field number 1

special_regs

Alias for field number 4

uninit_regs

Alias for field number 2

write_regs

Alias for field number 3

openpower.decoder.isa.comparefixed module

class openpower.decoder.isa.comparefixed.comparefixed

Bases: object

comparefixed_instrs = {'cmp': instruction_info(func=<function comparefixed.op_cmp>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['L', 'BF']), form='X', asmregs=[['BF', 'L', 'RA', 'RB']]), 'cmpeqb': instruction_info(func=<function comparefixed.op_cmpeqb>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BF']), form='X', asmregs=[['BF', 'RA', 'RB']]), 'cmpi': instruction_info(func=<function comparefixed.op_cmpi>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['L', 'SI', 'BF']), form='D', asmregs=[['BF', 'L', 'RA', 'SI']]), 'cmpl': instruction_info(func=<function comparefixed.op_cmpl>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['L', 'BF']), form='X', asmregs=[['BF', 'L', 'RA', 'RB']]), 'cmpli': instruction_info(func=<function comparefixed.op_cmpli>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['L', 'UI', 'BF']), form='D', asmregs=[['BF', 'L', 'RA', 'UI']]), 'cmprb': instruction_info(func=<function comparefixed.op_cmprb>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['L', 'BF']), form='X', asmregs=[['BF', 'L', 'RA', 'RB']])}

op_cmp(RA, RB, CR)

op_cmpeqb(RA, RB, CR)

op_cmpi(RA, CR)

op_cmpl(RA, RB, CR)

op_cmpli(RA, CR)

op_cmprb(RA, RB, CR)

openpower.decoder.isa.condition module

class openpower.decoder.isa.condition.condition

Bases: object

condition_instrs = {'crand': instruction_info(func=<function condition.op_crand>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'crandc': instruction_info(func=<function condition.op_crandc>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'creqv': instruction_info(func=<function condition.op_creqv>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'crnand': instruction_info(func=<function condition.op_crnand>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'crnor': instruction_info(func=<function condition.op_crnor>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'cror': instruction_info(func=<function condition.op_cror>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'crorc': instruction_info(func=<function condition.op_crorc>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'crxor': instruction_info(func=<function condition.op_crxor>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BT', 'BA', 'BB']), form='XL', asmregs=[['BT', 'BA', 'BB']]), 'mcrf': instruction_info(func=<function condition.op_mcrf>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BF', 'BFA']), form='XL', asmregs=[['BF', 'BFA']])}

op_crand(CR)

op_crandc(CR)

op_creqv(CR)

op_crnand(CR)

op_crnor(CR)

op_cror(CR)

op_crorc(CR)

op_crxor(CR)

op_mcrf(CR)

openpower.decoder.isa.fixedarith module

class openpower.decoder.isa.fixedarith.fixedarith

Bases: object

fixedarith_instrs = {'add': instruction_info(func=<function fixedarith.op_add>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'add.': instruction_info(func=<function fixedarith.op_add_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'addc': instruction_info(func=<function fixedarith.op_addc>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'addc.': instruction_info(func=<function fixedarith.op_addc_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'addco': instruction_info(func=<function fixedarith.op_addco>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'addco.': instruction_info(func=<function fixedarith.op_addco_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'adde': instruction_info(func=<function fixedarith.op_adde>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'adde.': instruction_info(func=<function fixedarith.op_adde_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'addeo': instruction_info(func=<function fixedarith.op_addeo>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'addeo.': instruction_info(func=<function fixedarith.op_addeo_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'addex': instruction_info(func=<function fixedarith.op_addex>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='Z23', asmregs=[['RT', 'RA', 'RB', 'CY']]), 'addi': instruction_info(func=<function fixedarith.op_addi>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['SI']), form='D', asmregs=[['RT', 'RA', 'SI']]), 'addic': instruction_info(func=<function fixedarith.op_addic>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['SI']), form='D', asmregs=[['RT', 'RA', 'SI']]), 'addic.': instruction_info(func=<function fixedarith.op_addic_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['SI']), form='D', asmregs=[['RT', 'RA', 'SI']]), 'addis': instruction_info(func=<function fixedarith.op_addis>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['SI']), form='D', asmregs=[['RT', 'RA', 'SI']]), 'addme': instruction_info(func=<function fixedarith.op_addme>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=0)']), 'addme.': instruction_info(func=<function fixedarith.op_addme_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=1)']), 'addmeo': instruction_info(func=<function fixedarith.op_addmeo>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=0)']), 'addmeo.': instruction_info(func=<function fixedarith.op_addmeo_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=1)']), 'addo': instruction_info(func=<function fixedarith.op_addo>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'addo.': instruction_info(func=<function fixedarith.op_addo_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'addpcis': instruction_info(func=<function fixedarith.op_addpcis>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['d0', 'd1', 'd2']), form='DX', asmregs=[['RT', 'D']]), 'addze': instruction_info(func=<function fixedarith.op_addze>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=0)']), 'addze.': instruction_info(func=<function fixedarith.op_addze_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=1)']), 'addzeo': instruction_info(func=<function fixedarith.op_addzeo>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=0)']), 'addzeo.': instruction_info(func=<function fixedarith.op_addzeo_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=1)']), 'darn': instruction_info(func=<function fixedarith.op_darn>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['L3']), form='X', asmregs=[['RT', 'L3']]), 'divd': instruction_info(func=<function fixedarith.op_divd>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divd.': instruction_info(func=<function fixedarith.op_divd_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divde': instruction_info(func=<function fixedarith.op_divde>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divde.': instruction_info(func=<function fixedarith.op_divde_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divdeo': instruction_info(func=<function fixedarith.op_divdeo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divdeo.': instruction_info(func=<function fixedarith.op_divdeo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divdeu': instruction_info(func=<function fixedarith.op_divdeu>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divdeu.': instruction_info(func=<function fixedarith.op_divdeu_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divdeuo': instruction_info(func=<function fixedarith.op_divdeuo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divdeuo.': instruction_info(func=<function fixedarith.op_divdeuo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divdo': instruction_info(func=<function fixedarith.op_divdo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divdo.': instruction_info(func=<function fixedarith.op_divdo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divdu': instruction_info(func=<function fixedarith.op_divdu>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divdu.': instruction_info(func=<function fixedarith.op_divdu_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divduo': instruction_info(func=<function fixedarith.op_divduo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divduo.': instruction_info(func=<function fixedarith.op_divduo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divw': instruction_info(func=<function fixedarith.op_divw>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divw.': instruction_info(func=<function fixedarith.op_divw_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divwe': instruction_info(func=<function fixedarith.op_divwe>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divwe.': instruction_info(func=<function fixedarith.op_divwe_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divweo': instruction_info(func=<function fixedarith.op_divweo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divweo.': instruction_info(func=<function fixedarith.op_divweo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divweu': instruction_info(func=<function fixedarith.op_divweu>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divweu.': instruction_info(func=<function fixedarith.op_divweu_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divweuo': instruction_info(func=<function fixedarith.op_divweuo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divweuo.': instruction_info(func=<function fixedarith.op_divweuo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['overflow', 'RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divwo': instruction_info(func=<function fixedarith.op_divwo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divwo.': instruction_info(func=<function fixedarith.op_divwo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'divwu': instruction_info(func=<function fixedarith.op_divwu>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'divwu.': instruction_info(func=<function fixedarith.op_divwu_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'divwuo': instruction_info(func=<function fixedarith.op_divwuo>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'divwuo.': instruction_info(func=<function fixedarith.op_divwuo_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'maddhd': instruction_info(func=<function fixedarith.op_maddhd>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='VA', asmregs=[['RT', 'RA.RB', 'RC']]), 'maddhdu': instruction_info(func=<function fixedarith.op_maddhdu>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='VA', asmregs=[['RT', 'RA.RB', 'RC']]), 'maddld': instruction_info(func=<function fixedarith.op_maddld>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='VA', asmregs=[['RT', 'RA.RB', 'RC']]), 'modsd': instruction_info(func=<function fixedarith.op_modsd>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'modsw': instruction_info(func=<function fixedarith.op_modsw>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'modud': instruction_info(func=<function fixedarith.op_modud>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'moduw': instruction_info(func=<function fixedarith.op_moduw>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'mulhd': instruction_info(func=<function fixedarith.op_mulhd>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=0)']), 'mulhd.': instruction_info(func=<function fixedarith.op_mulhd_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=1)']), 'mulhdu': instruction_info(func=<function fixedarith.op_mulhdu>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=0)']), 'mulhdu.': instruction_info(func=<function fixedarith.op_mulhdu_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=1)']), 'mulhw': instruction_info(func=<function fixedarith.op_mulhw>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=0)']), 'mulhw.': instruction_info(func=<function fixedarith.op_mulhw_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=1)']), 'mulhwu': instruction_info(func=<function fixedarith.op_mulhwu>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=0)']), 'mulhwu.': instruction_info(func=<function fixedarith.op_mulhwu_>, read_regs=OrderedSet(['RA', 'RB', 'RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(Rc=1)']), 'mulld': instruction_info(func=<function fixedarith.op_mulld>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'mulld.': instruction_info(func=<function fixedarith.op_mulld_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'mulldo': instruction_info(func=<function fixedarith.op_mulldo>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'mulldo.': instruction_info(func=<function fixedarith.op_mulldo_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'mulli': instruction_info(func=<function fixedarith.op_mulli>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['SI']), form='D', asmregs=[['RT', 'RA', 'SI']]), 'mullw': instruction_info(func=<function fixedarith.op_mullw>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'mullw.': instruction_info(func=<function fixedarith.op_mullw_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'mullwo': instruction_info(func=<function fixedarith.op_mullwo>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'mullwo.': instruction_info(func=<function fixedarith.op_mullwo_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'overflow']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'neg': instruction_info(func=<function fixedarith.op_neg>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=0)']), 'neg.': instruction_info(func=<function fixedarith.op_neg_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=1)']), 'nego': instruction_info(func=<function fixedarith.op_nego>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=0)']), 'nego.': instruction_info(func=<function fixedarith.op_nego_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=1)']), 'subf': instruction_info(func=<function fixedarith.op_subf>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'subf.': instruction_info(func=<function fixedarith.op_subf_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'subfc': instruction_info(func=<function fixedarith.op_subfc>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'subfc.': instruction_info(func=<function fixedarith.op_subfc_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'subfco': instruction_info(func=<function fixedarith.op_subfco>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'subfco.': instruction_info(func=<function fixedarith.op_subfco_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'subfe': instruction_info(func=<function fixedarith.op_subfe>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=0)']), 'subfe.': instruction_info(func=<function fixedarith.op_subfe_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=0', 'Rc=1)']), 'subfeo': instruction_info(func=<function fixedarith.op_subfeo>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'subfeo.': instruction_info(func=<function fixedarith.op_subfeo_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'subfic': instruction_info(func=<function fixedarith.op_subfic>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['SI']), form='D', asmregs=[['RT', 'RA', 'SI']]), 'subfme': instruction_info(func=<function fixedarith.op_subfme>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=0)']), 'subfme.': instruction_info(func=<function fixedarith.op_subfme_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=1)']), 'subfmeo': instruction_info(func=<function fixedarith.op_subfmeo>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=0)']), 'subfmeo.': instruction_info(func=<function fixedarith.op_subfmeo_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=1)']), 'subfo': instruction_info(func=<function fixedarith.op_subfo>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=0)']), 'subfo.': instruction_info(func=<function fixedarith.op_subfo_>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA', 'RB'], '(OE=1', 'Rc=1)']), 'subfze': instruction_info(func=<function fixedarith.op_subfze>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=0)']), 'subfze.': instruction_info(func=<function fixedarith.op_subfze_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=0', 'Rc=1)']), 'subfzeo': instruction_info(func=<function fixedarith.op_subfzeo>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=0)']), 'subfzeo.': instruction_info(func=<function fixedarith.op_subfzeo_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='XO', asmregs=[['RT', 'RA'], '(OE=1', 'Rc=1)'])}

op_add(RA, RB)

op_add_(RA, RB)

op_addc(RA, RB)

op_addc_(RA, RB)

op_addco(RA, RB)

op_addco_(RA, RB)

op_adde(RA, RB)

op_adde_(RA, RB)

op_addeo(RA, RB)

op_addeo_(RA, RB)

op_addex(RA, RB)

op_addi(RA)

op_addic(RA)

op_addic_(RA)

op_addis(RA)

op_addme(RA)

op_addme_(RA)

op_addmeo(RA)

op_addmeo_(RA)

op_addo(RA, RB)

op_addo_(RA, RB)

op_addpcis()

op_addze(RA)

op_addze_(RA)

op_addzeo(RA)

op_addzeo_(RA)

op_darn()

op_divd(RA, RB, RT)

op_divd_(RA, RB, RT)

op_divde(RA, RB, RT)

op_divde_(RA, RB, RT)

op_divdeo(RA, RB, RT)

op_divdeo_(RA, RB, RT)

op_divdeu(RA, RB, RT)

op_divdeu_(RA, RB, RT)

op_divdeuo(RA, RB, RT)

op_divdeuo_(RA, RB, RT)

op_divdo(RA, RB, RT)

op_divdo_(RA, RB, RT)

op_divdu(RA, RB, RT)

op_divdu_(RA, RB, RT)

op_divduo(RA, RB, RT)

op_divduo_(RA, RB, RT)

op_divw(RA, RB, RT)

op_divw_(RA, RB, RT)

op_divwe(RA, RB, RT)

op_divwe_(RA, RB, RT)

op_divweo(RA, RB, RT)

op_divweo_(RA, RB, RT)

op_divweu(RA, RB, RT)

op_divweu_(RA, RB, RT)

op_divweuo(RA, RB, RT)

op_divweuo_(RA, RB, RT)

op_divwo(RA, RB, RT)

op_divwo_(RA, RB, RT)

op_divwu(RA, RB, RT)

op_divwu_(RA, RB, RT)

op_divwuo(RA, RB, RT)

op_divwuo_(RA, RB, RT)

op_maddhd(RA, RB)

op_maddhdu(RA, RB)

op_maddld(RA, RB)

op_modsd(RA, RB, RT)

op_modsw(RA, RB, RT)

op_modud(RA, RB, RT)

op_moduw(RA, RB, RT)

op_mulhd(RA, RB)

op_mulhd_(RA, RB)

op_mulhdu(RA, RB)

op_mulhdu_(RA, RB)

op_mulhw(RA, RB, RT)

op_mulhw_(RA, RB, RT)

op_mulhwu(RA, RB, RT)

op_mulhwu_(RA, RB, RT)

op_mulld(RA, RB)

op_mulld_(RA, RB)

op_mulldo(RA, RB)

op_mulldo_(RA, RB)

op_mulli(RA)

op_mullw(RA, RB)

op_mullw_(RA, RB)

op_mullwo(RA, RB)

op_mullwo_(RA, RB)

op_neg(RA)

op_neg_(RA)

op_nego(RA)

op_nego_(RA)

op_subf(RA, RB)

op_subf_(RA, RB)

op_subfc(RA, RB)

op_subfc_(RA, RB)

op_subfco(RA, RB)

op_subfco_(RA, RB)

op_subfe(RA, RB)

op_subfe_(RA, RB)

op_subfeo(RA, RB)

op_subfeo_(RA, RB)

op_subfic(RA)

op_subfme(RA)

op_subfme_(RA)

op_subfmeo(RA)

op_subfmeo_(RA)

op_subfo(RA, RB)

op_subfo_(RA, RB)

op_subfze(RA)

op_subfze_(RA)

op_subfzeo(RA)

op_subfzeo_(RA)

openpower.decoder.isa.fixedldstcache module

class openpower.decoder.isa.fixedldstcache.fixedldstcache

Bases: object

fixedldstcache_instrs = {'lbzcix': instruction_info(func=<function fixedldstcache.op_lbzcix>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'ldcix': instruction_info(func=<function fixedldstcache.op_ldcix>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lhzcix': instruction_info(func=<function fixedldstcache.op_lhzcix>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lwzcix': instruction_info(func=<function fixedldstcache.op_lwzcix>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'stbcix': instruction_info(func=<function fixedldstcache.op_stbcix>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stdcix': instruction_info(func=<function fixedldstcache.op_stdcix>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'sthcix': instruction_info(func=<function fixedldstcache.op_sthcix>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stwcix': instruction_info(func=<function fixedldstcache.op_stwcix>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']])}

op_lbzcix(RA, RB)

op_ldcix(RA, RB)

op_lhzcix(RA, RB)

op_lwzcix(RA, RB)

op_stbcix(RA, RB, RS)

op_stdcix(RA, RB, RS)

op_sthcix(RA, RB, RS)

op_stwcix(RA, RB, RS)

openpower.decoder.isa.fixedload module

class openpower.decoder.isa.fixedload.fixedload

Bases: object

fixedload_instrs = {'lbz': instruction_info(func=<function fixedload.op_lbz>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lbzu': instruction_info(func=<function fixedload.op_lbzu>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lbzux': instruction_info(func=<function fixedload.op_lbzux>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lbzx': instruction_info(func=<function fixedload.op_lbzx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'ld': instruction_info(func=<function fixedload.op_ld>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['DS']), form='DS', asmregs=[['RT', 'DS(RA)']]), 'ldbrx': instruction_info(func=<function fixedload.op_ldbrx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'ldu': instruction_info(func=<function fixedload.op_ldu>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['DS']), form='DS', asmregs=[['RT', 'DS(RA)']]), 'ldux': instruction_info(func=<function fixedload.op_ldux>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'ldx': instruction_info(func=<function fixedload.op_ldx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lha': instruction_info(func=<function fixedload.op_lha>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lhau': instruction_info(func=<function fixedload.op_lhau>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lhaux': instruction_info(func=<function fixedload.op_lhaux>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lhax': instruction_info(func=<function fixedload.op_lhax>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lhbrx': instruction_info(func=<function fixedload.op_lhbrx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lhz': instruction_info(func=<function fixedload.op_lhz>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lhzu': instruction_info(func=<function fixedload.op_lhzu>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lhzux': instruction_info(func=<function fixedload.op_lhzux>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lhzx': instruction_info(func=<function fixedload.op_lhzx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lmw': instruction_info(func=<function fixedload.op_lmw>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='DQ', asmregs=[['RT', 'D(RA)']]), 'lq': instruction_info(func=<function fixedload.op_lq>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['DQ', 'RTp']), form='DQ', asmregs=[['RTp', 'DQ(RA)']]), 'lwa': instruction_info(func=<function fixedload.op_lwa>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['DS']), form='DS', asmregs=[['RT', 'DS(RA)']]), 'lwaux': instruction_info(func=<function fixedload.op_lwaux>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lwax': instruction_info(func=<function fixedload.op_lwax>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lwbrx': instruction_info(func=<function fixedload.op_lwbrx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lwz': instruction_info(func=<function fixedload.op_lwz>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lwzu': instruction_info(func=<function fixedload.op_lwzu>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RT', 'D(RA)']]), 'lwzux': instruction_info(func=<function fixedload.op_lwzux>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT', 'RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'lwzx': instruction_info(func=<function fixedload.op_lwzx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']])}

op_lbz(RA)

op_lbzu(RA)

op_lbzux(RA, RB)

op_lbzx(RA, RB)

op_ld(RA)

op_ldbrx(RA, RB)

op_ldu(RA)

op_ldux(RA, RB)

op_ldx(RA, RB)

op_lha(RA)

op_lhau(RA)

op_lhaux(RA, RB)

op_lhax(RA, RB)

op_lhbrx(RA, RB)

op_lhz(RA)

op_lhzu(RA)

op_lhzux(RA, RB)

op_lhzx(RA, RB)

op_lmw(RA)

op_lq(RA)

op_lwa(RA)

op_lwaux(RA, RB)

op_lwax(RA, RB)

op_lwbrx(RA, RB)

op_lwz(RA)

op_lwzu(RA)

op_lwzux(RA, RB)

op_lwzx(RA, RB)

openpower.decoder.isa.fixedlogical module

class openpower.decoder.isa.fixedlogical.fixedlogical

Bases: object

fixedlogical_instrs = {'and': instruction_info(func=<function fixedlogical.op_and>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'and.': instruction_info(func=<function fixedlogical.op_and_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'andc': instruction_info(func=<function fixedlogical.op_andc>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'andc.': instruction_info(func=<function fixedlogical.op_andc_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'andi.': instruction_info(func=<function fixedlogical.op_andi_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['UI']), form='D', asmregs=[['RA', 'RS', 'UI']]), 'andis.': instruction_info(func=<function fixedlogical.op_andis_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['UI']), form='D', asmregs=[['RA', 'RS', 'UI']]), 'bpermd': instruction_info(func=<function fixedlogical.op_bpermd>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB]']]), 'cmpb': instruction_info(func=<function fixedlogical.op_cmpb>, read_regs=OrderedSet(['RS', 'RB', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB']]), 'cntlzd': instruction_info(func=<function fixedlogical.op_cntlzd>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'cntlzd.': instruction_info(func=<function fixedlogical.op_cntlzd_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'cntlzw': instruction_info(func=<function fixedlogical.op_cntlzw>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'cntlzw.': instruction_info(func=<function fixedlogical.op_cntlzw_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'cnttzd': instruction_info(func=<function fixedlogical.op_cnttzd>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'cnttzd.': instruction_info(func=<function fixedlogical.op_cnttzd_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'cnttzw': instruction_info(func=<function fixedlogical.op_cnttzw>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'cnttzw.': instruction_info(func=<function fixedlogical.op_cnttzw_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'eqv': instruction_info(func=<function fixedlogical.op_eqv>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'eqv.': instruction_info(func=<function fixedlogical.op_eqv_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'extsb': instruction_info(func=<function fixedlogical.op_extsb>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'extsb.': instruction_info(func=<function fixedlogical.op_extsb_>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'extsh': instruction_info(func=<function fixedlogical.op_extsh>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'extsh.': instruction_info(func=<function fixedlogical.op_extsh_>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'extsw': instruction_info(func=<function fixedlogical.op_extsw>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=0)']), 'extsw.': instruction_info(func=<function fixedlogical.op_extsw_>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS'], '(Rc=1)']), 'nand': instruction_info(func=<function fixedlogical.op_nand>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'nand.': instruction_info(func=<function fixedlogical.op_nand_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'nor': instruction_info(func=<function fixedlogical.op_nor>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'nor.': instruction_info(func=<function fixedlogical.op_nor_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'or': instruction_info(func=<function fixedlogical.op_or>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'or.': instruction_info(func=<function fixedlogical.op_or_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'orc': instruction_info(func=<function fixedlogical.op_orc>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'orc.': instruction_info(func=<function fixedlogical.op_orc_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'ori': instruction_info(func=<function fixedlogical.op_ori>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['UI']), form='D', asmregs=[['RA', 'RS', 'UI']]), 'oris': instruction_info(func=<function fixedlogical.op_oris>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['UI']), form='D', asmregs=[['RA', 'RS', 'UI']]), 'popcntb': instruction_info(func=<function fixedlogical.op_popcntb>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', ''], 'RS']), 'popcntd': instruction_info(func=<function fixedlogical.op_popcntd>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', ''], 'RS']), 'popcntw': instruction_info(func=<function fixedlogical.op_popcntw>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', ''], 'RS']), 'prtyd': instruction_info(func=<function fixedlogical.op_prtyd>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS']]), 'prtyw': instruction_info(func=<function fixedlogical.op_prtyw>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(['RA']), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS']]), 'xor': instruction_info(func=<function fixedlogical.op_xor>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'xor.': instruction_info(func=<function fixedlogical.op_xor_>, read_regs=OrderedSet(['RS', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'xori': instruction_info(func=<function fixedlogical.op_xori>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['UI']), form='D', asmregs=[['RA', 'RS', 'UI']]), 'xoris': instruction_info(func=<function fixedlogical.op_xoris>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['UI']), form='D', asmregs=[['RA', 'RS', 'UI']])}

op_and(RS, RB)

op_and_(RS, RB)

op_andc(RS, RB)

op_andc_(RS, RB)

op_andi_(RS)

op_andis_(RS)

op_bpermd(RS, RB)

op_cmpb(RS, RB, RA)

op_cntlzd(RS)

op_cntlzd_(RS)

op_cntlzw(RS)

op_cntlzw_(RS)

op_cnttzd(RS)

op_cnttzd_(RS)

op_cnttzw(RS)

op_cnttzw_(RS)

op_eqv(RS, RB)

op_eqv_(RS, RB)

op_extsb(RS, RA)

op_extsb_(RS, RA)

op_extsh(RS, RA)

op_extsh_(RS, RA)

op_extsw(RS, RA)

op_extsw_(RS, RA)

op_nand(RS, RB)

op_nand_(RS, RB)

op_nor(RS, RB)

op_nor_(RS, RB)

op_or(RS, RB)

op_or_(RS, RB)

op_orc(RS, RB)

op_orc_(RS, RB)

op_ori(RS)

op_oris(RS)

op_popcntb(RS, RA)

op_popcntd(RS)

op_popcntw(RS, RA)

op_prtyd(RS)

op_prtyw(RS, RA)

op_xor(RS, RB)

op_xor_(RS, RB)

op_xori(RS)

op_xoris(RS)

openpower.decoder.isa.fixedshift module

class openpower.decoder.isa.fixedshift.fixedshift

Bases: object

fixedshift_instrs = {'extswsli': instruction_info(func=<function fixedshift.op_extswsli>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh']), form='XS', asmregs=[['RA', 'RS', 'SH'], '(Rc=0)']), 'extswsli.': instruction_info(func=<function fixedshift.op_extswsli_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh']), form='XS', asmregs=[['RA', 'RS', 'SH'], '(Rc=1)']), 'rldcl': instruction_info(func=<function fixedshift.op_rldcl>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['mb']), form='MDS', asmregs=[['RA', 'RS', 'RB', 'MB'], '(Rc=0)']), 'rldcl.': instruction_info(func=<function fixedshift.op_rldcl_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['mb']), form='MDS', asmregs=[['RA', 'RS', 'RB', 'MB'], '(Rc=1)']), 'rldcr': instruction_info(func=<function fixedshift.op_rldcr>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['me']), form='MDS', asmregs=[['RA', 'RS', 'RB', 'ME'], '(Rc=0)']), 'rldcr.': instruction_info(func=<function fixedshift.op_rldcr_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['me']), form='MDS', asmregs=[['RA', 'RS', 'RB', 'ME'], '(Rc=1)']), 'rldic': instruction_info(func=<function fixedshift.op_rldic>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'mb']), form='MD', asmregs=[['RA', 'RS', 'SH', 'MB'], '(Rc=0)']), 'rldic.': instruction_info(func=<function fixedshift.op_rldic_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'mb']), form='MD', asmregs=[['RA', 'RS', 'SH', 'MB'], '(Rc=1)']), 'rldicl': instruction_info(func=<function fixedshift.op_rldicl>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'mb']), form='MD', asmregs=[['RA', 'RS', 'SH', 'MB'], '(Rc=0)']), 'rldicl.': instruction_info(func=<function fixedshift.op_rldicl_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'mb']), form='MD', asmregs=[['RA', 'RS', 'SH', 'MB'], '(Rc=1)']), 'rldicr': instruction_info(func=<function fixedshift.op_rldicr>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'me']), form='MD', asmregs=[['RA', 'RS', 'SH', 'ME'], '(Rc=0)']), 'rldicr.': instruction_info(func=<function fixedshift.op_rldicr_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'me']), form='MD', asmregs=[['RA', 'RS', 'SH', 'ME'], '(Rc=1)']), 'rldimi': instruction_info(func=<function fixedshift.op_rldimi>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'mb']), form='MD', asmregs=[['RA', 'RS', 'SH', 'MB'], '(Rc=0)']), 'rldimi.': instruction_info(func=<function fixedshift.op_rldimi_>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh', 'mb']), form='MD', asmregs=[['RA', 'RS', 'SH', 'MB'], '(Rc=1)']), 'rlwimi': instruction_info(func=<function fixedshift.op_rlwimi>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['SH', 'MB', 'ME']), form='M', asmregs=[['RA', 'RS', 'SH', 'MB', 'ME'], '(Rc=0)']), 'rlwimi.': instruction_info(func=<function fixedshift.op_rlwimi_>, read_regs=OrderedSet(['RS', 'RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['SH', 'MB', 'ME']), form='M', asmregs=[['RA', 'RS', 'SH', 'MB', 'ME'], '(Rc=1)']), 'rlwinm': instruction_info(func=<function fixedshift.op_rlwinm>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['SH', 'MB', 'ME']), form='M', asmregs=[['RA', 'RS', 'SH', 'MB', 'ME'], '(Rc=0)']), 'rlwinm.': instruction_info(func=<function fixedshift.op_rlwinm_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['SH', 'MB', 'ME']), form='M', asmregs=[['RA', 'RS', 'SH', 'MB', 'ME'], '(Rc=1)']), 'rlwnm': instruction_info(func=<function fixedshift.op_rlwnm>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['MB', 'ME']), form='M', asmregs=[['RA', 'RS', 'RB', 'MB', 'ME'], '(Rc=0)']), 'rlwnm.': instruction_info(func=<function fixedshift.op_rlwnm_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['MB', 'ME']), form='M', asmregs=[['RA', 'RS', 'RB', 'MB', 'ME'], '(Rc=1)']), 'sld': instruction_info(func=<function fixedshift.op_sld>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'sld.': instruction_info(func=<function fixedshift.op_sld_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'slw': instruction_info(func=<function fixedshift.op_slw>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'slw.': instruction_info(func=<function fixedshift.op_slw_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'srad': instruction_info(func=<function fixedshift.op_srad>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'srad.': instruction_info(func=<function fixedshift.op_srad_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'sradi': instruction_info(func=<function fixedshift.op_sradi>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh']), form='XS', asmregs=[['RA', 'RS', 'SH'], '(Rc=0)']), 'sradi.': instruction_info(func=<function fixedshift.op_sradi_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(['sh']), form='XS', asmregs=[['RA', 'RS', 'SH'], '(Rc=1)']), 'sraw': instruction_info(func=<function fixedshift.op_sraw>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'sraw.': instruction_info(func=<function fixedshift.op_sraw_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'srawi': instruction_info(func=<function fixedshift.op_srawi>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(['SH']), form='X', asmregs=[['RA', 'RS', 'SH'], '(Rc=0)']), 'srawi.': instruction_info(func=<function fixedshift.op_srawi_>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA', 'CA', 'CA32']), special_regs=OrderedSet(), op_fields=OrderedSet(['SH']), form='X', asmregs=[['RA', 'RS', 'SH'], '(Rc=1)']), 'srd': instruction_info(func=<function fixedshift.op_srd>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'srd.': instruction_info(func=<function fixedshift.op_srd_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)']), 'srw': instruction_info(func=<function fixedshift.op_srw>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=0)']), 'srw.': instruction_info(func=<function fixedshift.op_srw_>, read_regs=OrderedSet(['RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RS', 'RB'], '(Rc=1)'])}

op_extswsli(RS)

op_extswsli_(RS)

op_rldcl(RB, RS)

op_rldcl_(RB, RS)

op_rldcr(RB, RS)

op_rldcr_(RB, RS)

op_rldic(RS)

op_rldic_(RS)

op_rldicl(RS)

op_rldicl_(RS)

op_rldicr(RS)

op_rldicr_(RS)

op_rldimi(RS, RA)

op_rldimi_(RS, RA)

op_rlwimi(RS, RA)

op_rlwimi_(RS, RA)

op_rlwinm(RS)

op_rlwinm_(RS)

op_rlwnm(RB, RS)

op_rlwnm_(RB, RS)

op_sld(RB, RS)

op_sld_(RB, RS)

op_slw(RB, RS)

op_slw_(RB, RS)

op_srad(RB, RS)

op_srad_(RB, RS)

op_sradi(RS)

op_sradi_(RS)

op_sraw(RB, RS)

op_sraw_(RB, RS)

op_srawi(RS)

op_srawi_(RS)

op_srd(RB, RS)

op_srd_(RB, RS)

op_srw(RB, RS)

op_srw_(RB, RS)

openpower.decoder.isa.fixedstore module

class openpower.decoder.isa.fixedstore.fixedstore

Bases: object

fixedstore_instrs = {'stb': instruction_info(func=<function fixedstore.op_stb>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'stbu': instruction_info(func=<function fixedstore.op_stbu>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'stbux': instruction_info(func=<function fixedstore.op_stbux>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stbx': instruction_info(func=<function fixedstore.op_stbx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'std': instruction_info(func=<function fixedstore.op_std>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['DS']), form='DS', asmregs=[['RS', 'DS(RA)']]), 'stdbrx': instruction_info(func=<function fixedstore.op_stdbrx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stdu': instruction_info(func=<function fixedstore.op_stdu>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['DS']), form='DS', asmregs=[['RS', 'DS(RA)']]), 'stdux': instruction_info(func=<function fixedstore.op_stdux>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stdx': instruction_info(func=<function fixedstore.op_stdx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'sth': instruction_info(func=<function fixedstore.op_sth>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'sthbrx': instruction_info(func=<function fixedstore.op_sthbrx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'sthu': instruction_info(func=<function fixedstore.op_sthu>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'sthux': instruction_info(func=<function fixedstore.op_sthux>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'sthx': instruction_info(func=<function fixedstore.op_sthx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stmw': instruction_info(func=<function fixedstore.op_stmw>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'stq': instruction_info(func=<function fixedstore.op_stq>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['DS', 'RSp']), form='DS', asmregs=[['RSp', 'DS(RA)']]), 'stw': instruction_info(func=<function fixedstore.op_stw>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'stwbrx': instruction_info(func=<function fixedstore.op_stwbrx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stwu': instruction_info(func=<function fixedstore.op_stwu>, read_regs=OrderedSet(['RA', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(['D']), form='D', asmregs=[['RS', 'D(RA)']]), 'stwux': instruction_info(func=<function fixedstore.op_stwux>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RA']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']]), 'stwx': instruction_info(func=<function fixedstore.op_stwx>, read_regs=OrderedSet(['RA', 'RB', 'RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']])}

op_stb(RA, RS)

op_stbu(RA, RS)

op_stbux(RA, RB, RS)

op_stbx(RA, RB, RS)

op_std(RA, RS)

op_stdbrx(RA, RB, RS)

op_stdu(RA, RS)

op_stdux(RA, RB, RS)

op_stdx(RA, RB, RS)

op_sth(RA, RS)

op_sthbrx(RA, RB, RS)

op_sthu(RA, RS)

op_sthux(RA, RB, RS)

op_sthx(RA, RB, RS)

op_stmw(RA)

op_stq(RA)

op_stw(RA, RS)

op_stwbrx(RA, RB, RS)

op_stwu(RA, RS)

op_stwux(RA, RB, RS)

op_stwx(RA, RB, RS)

openpower.decoder.isa.fixedtrap module

class openpower.decoder.isa.fixedtrap.fixedtrap

Bases: object

fixedtrap_instrs = {'isel': instruction_info(func=<function fixedtrap.op_isel>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR', 'RT']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BC']), form='A', asmregs=[['RT', 'RA', 'RB', 'BC']]), 'td': instruction_info(func=<function fixedtrap.op_td>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['TO']), form='X', asmregs=[['TO', 'RA', 'RB']]), 'tdi': instruction_info(func=<function fixedtrap.op_tdi>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['SI', 'TO']), form='D', asmregs=[['TO', 'RA', 'SI']]), 'tw': instruction_info(func=<function fixedtrap.op_tw>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['TO']), form='X', asmregs=[['TO', 'RA', 'RB']]), 'twi': instruction_info(func=<function fixedtrap.op_twi>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['SI', 'TO']), form='D', asmregs=[['TO', 'RA', 'SI']])}

op_isel(RA, RB, CR)

op_td(RA, RB)

op_tdi(RA)

op_tw(RA, RB)

op_twi(RA)

openpower.decoder.isa.mem module

core of the python-based POWER9 simulator

this is part of a cycle-accurate POWER9 simulator. its primary purpose is not speed, it is for both learning and educational purposes, as well as a method of verifying the HDL.

related bugs:

• https://bugs.libre-soc.org/show_bug.cgi?id=424

class openpower.decoder.isa.mem.Mem(row_bytes=8, initial_mem=None)

Bases: object

ld(address, width=8, swap=True, check_in_mem=False, instr_fetch=False)

memassign(addr, sz, val)

st(addr, v, width=8, swap=True)

openpower.decoder.isa.mem.swap_order(x, nbytes)

openpower.decoder.isa.radixmmu module

core of the python-based POWER9 simulator

this is part of a cycle-accurate POWER9 simulator. its primary purpose is not speed, it is for both learning and educational purposes, as well as a method of verifying the HDL.

related bugs:

• https://bugs.libre-soc.org/show_bug.cgi?id=604

openpower.decoder.isa.radixmmu.NLB(x)

Next Level Base right shifted by 8

openpower.decoder.isa.radixmmu.NLS(x)

Next Level Size (PATS and RPDS in same bits btw) NLS >= 5

class openpower.decoder.isa.radixmmu.RADIX(mem, caller)

Bases: object

ld(address, width=8, swap=True, check_in_mem=False, instr_fetch=False)

memassign(addr, sz, val)

st(address, v, width=8, swap=True)

openpower.decoder.isa.radixmmu.RPDB(x)

Root Page Directory Base power isa docs says 4:55 investigate

openpower.decoder.isa.radixmmu.RTS(data)

openpower.decoder.isa.radixmmu.RTS1(data)

openpower.decoder.isa.radixmmu.RTS2(data)

class openpower.decoder.isa.radixmmu.TestRadixMMU(methodName='runTest')

Bases: unittest.case.TestCase

test_RPDB()

test_genmask()

test_get_pgtable_addr()

test_walk_tree_1()

test_walk_tree_2()

openpower.decoder.isa.radixmmu.addrshift(addr, shift)

openpower.decoder.isa.radixmmu.genmask(shift, size)

openpower.decoder.isa.radixmmu.rpte_leaf(r)

openpower.decoder.isa.radixmmu.rpte_valid(r)

openpower.decoder.isa.simplev module

class openpower.decoder.isa.simplev.simplev

Bases: object

op_setvl(RA, SVSTATE)

op_setvl_(RA, SVSTATE)

simplev_instrs = {'setvl': instruction_info(func=<function simplev.op_setvl>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['SVSTATE', 'RT']), special_regs=OrderedSet(['SVSTATE']), op_fields=OrderedSet(['SVi', 'vs', 'ms']), form='SVL', asmregs=[['RT', ''], 'RA,', 'SVi,', 'vs,', 'ms']), 'setvl.': instruction_info(func=<function simplev.op_setvl_>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['SVSTATE', 'RT']), special_regs=OrderedSet(['SVSTATE']), op_fields=OrderedSet(['SVi', 'vs', 'ms']), form='SVL', asmregs=[['RT', ''], 'RA,', 'SVi,', 'vs,', 'ms'])}

openpower.decoder.isa.sprset module

class openpower.decoder.isa.sprset.sprset

Bases: object

op_dcbz(RA, RB)

op_mcrxrx(CR)

op_mfcr(CR)

op_mfmsr(MSR)

op_mfocrf(RT, CR)

op_mfspr()

op_mtcrf(RS, CR)

op_mtmsr(RS, MSR)

op_mtmsrd(RS, MSR)

op_mtocrf(RS, CR)

op_mtspr(RS)

op_setb(CR)

op_tlbie(RB)

sprset_instrs = {'dcbz': instruction_info(func=<function sprset.op_dcbz>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RA', 'RB']]), 'mcrxrx': instruction_info(func=<function sprset.op_mcrxrx>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BF']), form='X', asmregs=[['BF']]), 'mfcr': instruction_info(func=<function sprset.op_mfcr>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR', 'RT']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(), form='XFX', asmregs=[['RT']]), 'mfmsr': instruction_info(func=<function sprset.op_mfmsr>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR', 'RT']), special_regs=OrderedSet(['MSR']), op_fields=OrderedSet(), form='X', asmregs=[['RT']]), 'mfocrf': instruction_info(func=<function sprset.op_mfocrf>, read_regs=OrderedSet(['RT']), uninit_regs=OrderedSet(['RT']), write_regs=OrderedSet(['RT', 'CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['FXM']), form='XFX', asmregs=[['RT', 'FXM']]), 'mfspr': instruction_info(func=<function sprset.op_mfspr>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(['spr']), form='XFX', asmregs=[['RT', 'SPR']]), 'mtcrf': instruction_info(func=<function sprset.op_mtcrf>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['FXM']), form='XFX', asmregs=[['FXM', 'RS']]), 'mtmsr': instruction_info(func=<function sprset.op_mtmsr>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR']), special_regs=OrderedSet(['MSR']), op_fields=OrderedSet(['L1']), form='X', asmregs=[['RS', 'L1']]), 'mtmsrd': instruction_info(func=<function sprset.op_mtmsrd>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR']), special_regs=OrderedSet(['MSR']), op_fields=OrderedSet(['L1']), form='X', asmregs=[['RS', 'L1']]), 'mtocrf': instruction_info(func=<function sprset.op_mtocrf>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['FXM']), form='XFX', asmregs=[['FXM', 'RS']]), 'mtspr': instruction_info(func=<function sprset.op_mtspr>, read_regs=OrderedSet(['RS']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['spr']), form='XFX', asmregs=[['SPR', 'RS']]), 'setb': instruction_info(func=<function sprset.op_setb>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['CR', 'RT']), special_regs=OrderedSet(['CR']), op_fields=OrderedSet(['BFA']), form='X', asmregs=[['RT', 'BFA']]), 'tlbie': instruction_info(func=<function sprset.op_tlbie>, read_regs=OrderedSet(['RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RB', 'RS', 'RIC', 'PRS', 'R']])}

openpower.decoder.isa.stringldst module

class openpower.decoder.isa.stringldst.stringldst

Bases: object

op_lswi(RA)

op_lswx(RA, RB)

op_stswi(RA)

op_stswx(RA, RB)

stringldst_instrs = {'lswi': instruction_info(func=<function stringldst.op_lswi>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['NB']), form='X', asmregs=[['RT', 'RA', 'NB']]), 'lswx': instruction_info(func=<function stringldst.op_lswx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(['RT']), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RT', 'RA', 'RB']]), 'stswi': instruction_info(func=<function stringldst.op_stswi>, read_regs=OrderedSet(['RA']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(['NB']), form='X', asmregs=[['RS', 'RA', 'NB']]), 'stswx': instruction_info(func=<function stringldst.op_stswx>, read_regs=OrderedSet(['RA', 'RB']), uninit_regs=OrderedSet(), write_regs=OrderedSet(), special_regs=OrderedSet(), op_fields=OrderedSet(), form='X', asmregs=[['RS', 'RA', 'RB']])}

openpower.decoder.isa.system module

class openpower.decoder.isa.system.system

Bases: object

op_hrfid(MSR)

op_rfid(MSR)

op_rfscv(MSR, CTR, LR)

op_sc(MSR)

op_scv(LR, MSR)

system_instrs = {'hrfid': instruction_info(func=<function system.op_hrfid>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR']), special_regs=OrderedSet(['MSR']), op_fields=OrderedSet(), form='XL', asmregs=[]), 'rfid': instruction_info(func=<function system.op_rfid>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR']), special_regs=OrderedSet(['MSR']), op_fields=OrderedSet(), form='XL', asmregs=[]), 'rfscv': instruction_info(func=<function system.op_rfscv>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR', 'CTR', 'LR']), special_regs=OrderedSet(['MSR', 'CTR', 'LR']), op_fields=OrderedSet(), form='XL', asmregs=[]), 'sc': instruction_info(func=<function system.op_sc>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['MSR']), special_regs=OrderedSet(['MSR']), op_fields=OrderedSet(), form='SC', asmregs=[['LEV']]), 'scv': instruction_info(func=<function system.op_scv>, read_regs=OrderedSet(), uninit_regs=OrderedSet(), write_regs=OrderedSet(['LR', 'MSR']), special_regs=OrderedSet(['LR', 'MSR']), op_fields=OrderedSet(), form='SC', asmregs=[['LEV']])}

openpower.decoder.isa.test_caller module

class openpower.decoder.isa.test_caller.DecoderTestCase(methodName='runTest')

Bases: nmutil.formaltest.FHDLTestCase

run_tst_program(prog, initial_regs=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

test_add()

test_add_compare()

test_addi()

test_addpcis()

test_branch()

test_branch_cond()

test_branch_ctr()

test_branch_link()

test_branch_loop()

test_branch_loop_ctr()

test_cmp()

test_cmpeqb()

test_cntlz()

test_load_store()

test_mtcrf()

test_popcnt()

test_prty()

test_rldic()

test_rlwimi()

test_rlwinm()

test_slw()

test_srw()

class openpower.decoder.isa.test_caller.Register(num)

Bases: object

openpower.decoder.isa.test_caller.run_tst(generator, initial_regs, initial_sprs=None, svstate=0, mmu=False, initial_cr=0, mem=None)

openpower.decoder.isa.test_caller_radix module

class openpower.decoder.isa.test_caller_radix.DecoderTestCase(methodName='runTest')

Bases: nmutil.formaltest.FHDLTestCase

run_tst_program(prog, initial_regs=None, initial_mem=None, initial_sprs=None)

test_load()

test_load_pid_1()

test_load_store()

openpower.decoder.isa.test_caller_setvl module

class openpower.decoder.isa.test_caller_setvl.DecoderTestCase(methodName='runTest')

Bases: nmutil.formaltest.FHDLTestCase

run_tst_program(prog, initial_regs=None, svstate=None)

test_setvl_1()

test_sv_add()

openpower.decoder.isa.test_caller_svp64 module

class openpower.decoder.isa.test_caller_svp64.DecoderTestCase(methodName='runTest')

Bases: nmutil.formaltest.FHDLTestCase

run_tst_program(prog, initial_regs=None, svstate=None)

test_sv_add()

test_sv_add_2()

test_sv_add_3()

test_sv_add_cr()

test_sv_add_vl_0()

test_sv_load_store()

openpower.decoder.isa.test_caller_svp64_predication module

class openpower.decoder.isa.test_caller_svp64_predication.DecoderTestCase(methodName='runTest')

Bases: nmutil.formaltest.FHDLTestCase

run_tst_program(prog, initial_regs=None, svstate=None, initial_cr=0)

test_crpred_reentrant()

test_intpred_reentrant()

test_intpred_twinpred()

test_intpred_vcompress()

test_intpred_vexpand()

test_shift_one_by_r3_dest()

test_shift_one_by_r3_source()

test_sv_add_cr_pred()

test_sv_add_intpred()

test_sv_extsw_intpred()

test_sv_extsw_intpred_dz()

tst_sv_add_2()

tst_sv_add_3()

tst_sv_add_cr()

tst_sv_add_vl_0()

tst_sv_load_store()

Module contents