mirror of
https://github.com/radareorg/radare2.git
synced 2025-02-14 19:08:04 +00:00
6d1242c18d
This will cover 99% of the commands implemented correctly/currently (via capstone). However, since this doco is a complete list of mnemonics as of 2016, it will cover all the instructions when a more complete implementation of sysz is build for r2. Thanks to @mainframed for parsing the original docs to create the raw instruction files.
1144 lines
32 KiB
Plaintext
1144 lines
32 KiB
Plaintext
a=Add (32)
|
|
ad=Add Normalized (LH)
|
|
adb=Add (LB)
|
|
adbr=Add (LB)
|
|
adr=Add Normalized (LH)
|
|
adtr=Add (LD)
|
|
adtra=ADD (LD)
|
|
ae=Add Normalized (SH)
|
|
aeb=Add (SB)
|
|
aebr=Add (SB)
|
|
aer=Add Normalized (SH)
|
|
afi=Add Immediate (32)
|
|
ag=Add (64)
|
|
agf=Add (64\32)
|
|
agfi=Add Immediate (64\32)
|
|
agfr=Add (64\32)
|
|
aghi=Add Halfword Immediate (64\16)
|
|
aghik=Add Immediate (64\16)
|
|
agr=Add (64)
|
|
agrk=Add (64)
|
|
agsi=Add Immediate (64\8)
|
|
ah=Add Halfword (32\16)
|
|
ahhhr=Add High (32)
|
|
ahhlr=Add High (32)
|
|
ahi=Add Halfword Immediate (32\16)
|
|
ahik=Add Immediate (32\16)
|
|
ahy=Add Halfword (32\16)
|
|
aih=Add Immediate High (32)
|
|
al=Add Logical (32)
|
|
alc=Add Logical with Carry (32)
|
|
alcg=Add Logical with Carry (64)
|
|
alcgr=Add Logical with Carry (64)
|
|
alcr=Add Logical with Carry (32)
|
|
alfi=Add Logical Immediate (32)
|
|
alg=Add Logical (64)
|
|
algf=Add Logical (64\32)
|
|
algfi=Add Logical Immediate (64\32)
|
|
algfr=Add Logical (64\32)
|
|
alghsik=Add Logical with Signed Immediate
|
|
algr=Add Logical (64)
|
|
algrk=Add Logical (64)
|
|
algsi=Add Logical with Signed Immediate (64\8)
|
|
alhhhr=Add Logical High (32)
|
|
alhhlr=Add Logical High (32)
|
|
alhsik=Add Logical with Signed Immediate
|
|
alr=Add Logical (32)
|
|
alrk=Add Logical (32)
|
|
alsi=Add Logical with Signed Immediate (32\8)
|
|
alsih=Add Logical with Signed Immediate High
|
|
alsihn=Add Logical with Signed Immediate High
|
|
aly=Add Logical (32)
|
|
ap=Add Decimal
|
|
ar=Add (32)
|
|
ark=Add (32)
|
|
asi=Add Immediate (32\8)
|
|
au=Add Unnormalized (SH)
|
|
aur=Add Unnormalized (SH)
|
|
aw=Add Unnormalized (LH)
|
|
awr=Add Unnormalized (LH)
|
|
axbr=Add (EB)
|
|
axr=Add Normalized (EH)
|
|
axtr=Add (ED)
|
|
axtra=ADD (ED)
|
|
ay=Add (32)
|
|
bakr=Branch and Stack
|
|
bal=Branch and Link
|
|
balr=Branch and Link
|
|
bas=Branch and Save
|
|
basr=Branch and Save
|
|
bassm=Branch and Save and Set Mode
|
|
bc=Branch on Condition
|
|
br=Branch on Condition
|
|
bcr=Branch on Condition
|
|
bct=Branch on Count (32)
|
|
bctg=Branch on Count (64)
|
|
bctgr=Branch on Count (64)
|
|
bctr=Branch on Count (32)
|
|
bpp=Branch Prediction Preload
|
|
bprp=Branch Prediction Relative Preload
|
|
bras=Branch Relative and Save
|
|
brasl=Branch Relative and Save Long
|
|
brc=Branch Relative on Condition
|
|
brcl=Branch Relative on Condition Long
|
|
brct=Branch Relative on Count (32)
|
|
brctg=Branch Relative on Count (64)
|
|
brcth=Branch Relative on Count High (32)
|
|
brxh=Branch Relative on Index High (32)
|
|
brxhg=Branch Relative on Index High (64)
|
|
brxle=Branch Relative on Index Low or Equal (32)
|
|
brxlg=Branch Relative on Index Low or Equal (64)
|
|
bsa=Branch and Set Authority
|
|
bsg=Branch in Subspace Group
|
|
bsm=Branch and Set Mode
|
|
bxh=Branch on Index High (32)
|
|
bxhg=Branch on Index High (64)
|
|
bxle=Branch on Index Low or Equal (32)
|
|
bxleg=Branch on Index Low or Equal (64)
|
|
c=Compare (32)
|
|
cd=Compare (LH)
|
|
cdb=Compare (LB)
|
|
cdbr=Compare (LB)
|
|
cdfbr=Convert from Fixed (LB\32)
|
|
cdfbra=Convert from Fixed (LB\32)
|
|
cdfr=Convert from Fixed (LH\32)
|
|
cdftr=Convert from Fixed (LD\32)
|
|
cdgbr=Convert from Fixed (LB\64)
|
|
cdgbra=Convert from Fixed (LB\64)
|
|
cdgr=Convert from Fixed (LH\64)
|
|
cdgtr=Convert from Fixed (LD\64)
|
|
cdgtra=Convert from Fixed (LD\64)
|
|
cdlfbr=Convert from Logical (LB\32)
|
|
cdlftr=Convert from Logical (LD\32)
|
|
cdlgbr=Convert from Logical (LB\64)
|
|
cdlgtr=Convert from Logical (LD\64)
|
|
cdpt=Convert from Packed (To Long DFP)
|
|
cdr=Compare (LH)
|
|
cds=Compare Double and Swap (32)
|
|
cdsg=Compare Double and Swap (64)
|
|
cdstr=Convert from Signed Packed (LD\64)
|
|
cdsy=Compare Double and Swap (32)
|
|
cdtr=Compare (LD)
|
|
cdutr=Convert from Unsigned Packed (LD\64)
|
|
cdzt=Comvert from Zoned (to long DFP)
|
|
ce=Compare (SH)
|
|
ceb=Compare (SB)
|
|
cebr=Compare (SB)
|
|
cedtr=Compare Biased Exponent (LD)
|
|
cefbr=Convert from Fixed (SB\32)
|
|
cefbra=Convert from Fixed (SB\32)
|
|
cefr=Convert from Fixed (SH\32)
|
|
cegbr=Convert from Fixed (SB\64)
|
|
cegbra=Convert from Fixed (SB\64)
|
|
cegr=Convert from Fixed (SH\64)
|
|
celfbr=Convert from Logical (SB\32)
|
|
celgbr=Convert from Logical (SB\64)
|
|
cer=Compare (SH)
|
|
cextr=Compare Biased Exponent (ED)
|
|
cfc=Compare and Form Codeword
|
|
cfdbr=Convert to Fixed (32\LB)
|
|
cfdbra=Convert to Fixed (32\LB)
|
|
cfdr=Convert to Fixed (32\LH)
|
|
cfdtr=Convert to Fixed (32\LD)
|
|
cfebr=Convert to Fixed (32\SB)
|
|
cfebra=Convert to Fixed (32\SB)
|
|
cfer=Convert to Fixed (32\SH)
|
|
cfi=Compare Immediate (32)
|
|
cfxbr=Convert to Fixed (32\EB)
|
|
cfxbra=Convert to Fixed (32\EB)
|
|
cfxr=Convert to Fixed (32\EH)
|
|
cfxtr=Convert to Fixed (32\ED)
|
|
cg=Compare (64)
|
|
cgdbr=Convert to Fixed (64\LB)
|
|
cgdbra=Convert to Fixed (64\LB)
|
|
cgdr=Convert to Fixed (64\LH)
|
|
cgdtr=Convert to Fixed (64\LD)
|
|
cgdtra=Convert to Fixed (64\LD)
|
|
cgebr=Convert to Fixed (64\SB)
|
|
cgebra=Convert to Fixed (64\SB)
|
|
cger=Convert to Fixed (64\SH)
|
|
cgf=Compare (64\32)
|
|
cgfi=Compare Immediate (64\32)
|
|
cgfr=Compare (64\32)
|
|
cgfrl=Compare Relative Long (64\32)
|
|
cgh=Compare Halfword (64\16)
|
|
cghi=Compare Halfword Immediate (64\16)
|
|
cghrl=Compare Halfword Relative Long (64\16)
|
|
cghsi=Compare Halfword Immediate (64\16)
|
|
cgib=Compare Immediate and Branch (64\8)
|
|
cgij=Compare Immediate and Branch Relative
|
|
cgit=Compare Immediate and Trap (64\16)
|
|
cgr=Compare (64)
|
|
cgrb=Compare and Branch (64)
|
|
cgrj=Compare and Branch Relative (64)
|
|
cgrl=Compare Relative Long (64)
|
|
cgrt=Compare and Trap (64)
|
|
cgxbr=Convert to Fixed (64\EB)
|
|
cgxbra=Convert to Fixed (64\EB)
|
|
cgxr=Convert to Fixed (64\EH)
|
|
cgxtr=Convert to Fixed (64\ED)
|
|
cgxtra=Convert to Fixed (64\ED)
|
|
ch=Compare Halfword (32\16)
|
|
chf=Compare High (32)
|
|
chhr=Compare High (32)
|
|
chhsi=Compare Halfword Immediate (16\16)
|
|
chi=Compare Halfword Immediate (32\16)
|
|
chlr=Compare High (32)
|
|
chrl=Compare Halfword Relative Long (32\16)
|
|
chsi=Compare Halfword Immediate (32\16)
|
|
chy=Compare Halfword (32\16)
|
|
cib=Compare Immediate and Branch (32\8)
|
|
cih=Compare Immediate High (32)
|
|
cij=Compare Immediate and Branch Relative
|
|
cit=Compare Immediate and Trap (32\16)
|
|
cksm=Checksum
|
|
cl=Compare Logical (32)
|
|
clc=Compare Logical (character)
|
|
clcl=Compare Logical Long
|
|
clcle=Compare Logical Long Extended
|
|
clclu=Compare Logical Long Unicode
|
|
clfdbr=Convert to Logical (32\LB)
|
|
clfdtr=Convert to Logical (32\LD)
|
|
clfebr=Convert to Logical (32\SB)
|
|
clfhsi=Compare Logical Immediate (32\16)
|
|
clfi=Compare Logical Immediate (32)
|
|
clfit=Compare Logical Immediate and Trap
|
|
clfxbr=Convert to Logical (32\EB)
|
|
clfxtr=Convert to Logical (32\ED)
|
|
clg=Compare Logical (64)
|
|
clgdbr=Convert to Logical (64\LB)
|
|
clgdtr=Convert to Logical (64\LD)
|
|
clgebr=Convert to Logical (64\SB)
|
|
clgf=Compare Logical (64\32)
|
|
clgfi=Compare Logical Immediate (64\32)
|
|
clgfr=Compare Logical (64\32)
|
|
clgfrl=Compare Logical Relative Long (64\32)
|
|
clghrl=Compare Logical Relative Long (64\16)
|
|
clghsi=Compare Logical Immediate (64\16)
|
|
clgib=Compare Logical Immediate and Branch
|
|
clgij=Compare Logical Immediate and Branch
|
|
clgit=Compare Logical Immedical and Trap
|
|
clgr=Compare Logical (64)
|
|
clgrb=Compare Logical and Branch (64)
|
|
clgrj=Compare Logical and Branch Relative (64
|
|
clgrl=Compare Logical Relative Long (64)
|
|
clgrt=Compare Logical and Trap (64)
|
|
clgt=Compare Logical and Trap (64)
|
|
clgxbr=Convert to Logical (64\EB)
|
|
clgxtr=Convert to Logical (64\ED)
|
|
clhf=Compare Logical High (32)
|
|
clhhr=Compare Logical High (32)
|
|
clhhsi=Compare Logical Immediate (16\16)
|
|
clhlr=Compare Logical High (32)
|
|
clhrl=Compare Logical Relative Long (32\16)
|
|
cli=Compare Logical Immediate
|
|
clib=Compare Logical Immediate and Branch
|
|
clih=Compare Logical Immediate High (32)
|
|
clij=Compare Logical Immediate and Branch
|
|
cliy=Compare Logical Immediate
|
|
clm=Compare Logical Char. under Mask (low)
|
|
clmh=Compare Logical Char. under Mask (high)
|
|
clmy=Compare Logical Char. under Mask (low)
|
|
clr=Compare Logical (32)
|
|
clrb=Compare Logical and Branch (32)
|
|
clrj=Compare Logical and Branch Relative (32)
|
|
clrl=Compare Logical Relative Long (32)
|
|
clrt=Compare Logical and Trap (32)
|
|
clst=Compare Logical String
|
|
clt=Compare Logical and Trap (32)
|
|
cly=Compare Logical (32)
|
|
cmpsc=Compression Call
|
|
cp=Compare Decimal
|
|
cpdt=Convert to Packed (From Long DFP)
|
|
cpsdr=Copy Sign (L)
|
|
cpxt=Convert to Packed (From Extended DFP)
|
|
cpya=Copy Access
|
|
cr=Compare (32)
|
|
crb=Compare and Branch (32)
|
|
crdte=Compare and Replace DAT Table Entry
|
|
crj=Compare and Branch Relative (32)
|
|
crl=Compare Relative Long (32)
|
|
crt=Compare and Trap (32)
|
|
cs=Compare and Swap (32)
|
|
csch=Clear Subchannel
|
|
csdtr=Convert to Signed Packed (64\LD)
|
|
csg=Compare and Swap (64)
|
|
csp=Compare and Swap and Purge (32)
|
|
cspg=Compare and Swap and Purge (64)
|
|
csst=Compare and Swap and Store
|
|
csxtr=Convert to Signed Packed (128\ED)
|
|
csy=Compare and Swap (32)
|
|
cu12=Convert UTF-8 to UTF-16
|
|
cu14=Convert UTF-8 to UTF-32
|
|
cu21=Convert UTF-16 to UTF-8
|
|
cu24=Convert UTF-16 to UTF-32
|
|
cu41=Convert UTF-32 to UTF-8
|
|
cu42=Convert UTF-32 to UTF-16
|
|
cudtr=Convert to Unsigned Packed (64\LD)
|
|
cuse=Compare until Substring Equal
|
|
cutfu=Convert UTF-8 to Unicode
|
|
cuutf=Convert Unicode to UTF-8
|
|
cuxtr=Convert to Unsigned Packed (128\ED)
|
|
cvb=Convert to Binary (32)
|
|
cvbg=Convert to Binary (64)
|
|
cvby=Convert to Binary (32)
|
|
cvd=Convert to Decimal (32)
|
|
cvdg=Convert to Decimal (64)
|
|
cvdy=Convert to Decimal (32)
|
|
cxbr=Compare (EB)
|
|
cxfbr=Convert from Fixed (EB\32)
|
|
cxfbra=Convert from Fixed (EB\32)
|
|
cxfr=Convert from Fixed (EH\32)
|
|
cxftr=Convert from Fixed (ED\32)
|
|
cxgbr=Convert from Fixed (EB\64)
|
|
cxgbra=Convert from Fixed (EB\64)
|
|
cxgr=Convert from Fixed (EH\64)
|
|
cxgtr=Convert from Fixed (ED\64)
|
|
cxgtra=Convert from Fixed (ED\64)
|
|
cxlfbr=Convert from Logical (EB\32)
|
|
cxlftr=Convert from Logical (ED\32)
|
|
cxlgbr=Convert from Logical (EB\64)
|
|
cxlgtr=Convert from Logical (ED\64)
|
|
cxpt=Convert from Packed (To Extended DFP
|
|
cxr=Compare (EH)
|
|
cxstr=Convert from Signed Packed (ED\128)
|
|
cxtr=Compare (ED)
|
|
cxutr=Convert from Unsigned Packed (ED\128
|
|
cxzt=Comvert from Zoned (to extended DFP)
|
|
cy=Compare (32)
|
|
czdt=Comvert to Zoned (from long DFP)
|
|
czxt=Comvert to Zoned (from extended DFP)
|
|
d=Divide (32\64)
|
|
dd=Divide (LH)
|
|
ddb=Divide (LB)
|
|
ddbr=Divide (LB)
|
|
ddr=Divide (LH)
|
|
ddtr=Divide (LD)
|
|
ddtra=Divide (LD)
|
|
de=Divide (SH)
|
|
deb=Divide (SB)
|
|
debr=Divide (SB)
|
|
der=Divide (SH)
|
|
didbr=Divide to Integer (LB)
|
|
diebr=Divide to Integer (SB)
|
|
dl=Divide Logical (32\64)
|
|
dlg=Divide Logical (64\128)
|
|
dlgr=Divide Logical (64\128)
|
|
dlr=Divide Logical (32\64)
|
|
dp=Divide Decimal
|
|
dr=Divide (32\64)
|
|
dsg=Divide Single (64)
|
|
dsgf=Divide Single (64\32)
|
|
dsgfr=Divide Single (64\32)
|
|
dsgr=Divide Single (64)
|
|
dxbr=Divide (EB)
|
|
dxr=Divide (EH)
|
|
dxtr=Divide (ED)
|
|
dxtra=Divide (ED)
|
|
ear=Extract Access
|
|
ecag=Extract CPU Attribute
|
|
ectg=Extract CPU Time
|
|
ed=Edit
|
|
edmk=Edit and Mark
|
|
eedtr=Extract Biased Exponent (64\LD)
|
|
eextr=Extract Biased Exponent (64\ED)
|
|
efpc=Extract FPC
|
|
epair=Extract Primary ASN and Instance
|
|
epar=Extract Primary ASN
|
|
epsw=Extract PSW
|
|
ereg=Extract Stacked Registers (32)
|
|
eregg=Extract Stacked Registers (64)
|
|
esair=Extract Secondary ASN and Instance
|
|
esar=Extract Secondary ASN
|
|
esdtr=Extract Significance (64\LD)
|
|
esea=Extract and Set Extended Authority
|
|
esta=Extract Stacked State
|
|
esxtr=Extract Significance (64\ED)
|
|
etnd=Extract Transaction Nesting Depth
|
|
ex=Execute
|
|
exrl=Execute Relative Long
|
|
fidbr=Load FP Integer (LB)
|
|
fidbra=Load FP Integer (LB)
|
|
fidr=Load FP Integer (LH)
|
|
fidtr=Load FP Integer (LD)
|
|
fiebr=Load FP Integer (SB)
|
|
fiebra=Load FP Integer (SB)
|
|
fier=Load FP Integer (SH)
|
|
fixbr=Load FP Integer (EB)
|
|
fixbra=Load FP Integer (EB)
|
|
fixr=Load FP Integer (EH)
|
|
fixtr=Load FP Integer (ED)
|
|
flogr=Find Leftmost One
|
|
hdr=Halve (LH)
|
|
her=Halve (SH)
|
|
hsch=Halt Subchannel
|
|
iac=Insert Address Space Control
|
|
ic=Insert Character
|
|
icm=Insert Characters under Mask (low)
|
|
icmh=Insert Characters under Mask (high)
|
|
icmy=Insert Characters under Mask (low)
|
|
icy=Insert Character
|
|
idte=Invalidate DAT Table Entry
|
|
iedtr=Insert Biased Exponent (LD\64&LD)
|
|
iextr=Insert Biased Exponent (ED\64&ED)
|
|
iihf=Insert Immediate (high)
|
|
iihh=Insert Immediate (high high)
|
|
iihl=Insert Immediate (high low)
|
|
iilf=Insert Immediate (low)
|
|
iilh=Insert Immediate (low high)
|
|
iill=Insert Immediate (low low)
|
|
ipk=Insert PSW Key
|
|
ipm=Insert Program Mask
|
|
ipte=Invalidate Page Table Entry
|
|
iske=Insert Storage Key Extended
|
|
ivsk=Insert Virtual Storage Key
|
|
kdb=Compare and Signal (LB)
|
|
kdbr=Compare and Signal (LB)
|
|
kdtr=Compare and Signal (LD)
|
|
keb=Compare and Signal (SB)
|
|
kebr=Compare and Signal (SB)
|
|
kimd=Compute Intermediate Message Digest
|
|
klmd=Compute Last Message Digest
|
|
km=Cipher Message
|
|
kmac=Compute Message Authentication Code
|
|
kmc=Cipher Message with Chaining
|
|
kmctr=Cipher Message with Counter
|
|
kmf=Cipher Message with Cipher Feedback
|
|
kmo=Cipher Message with Output Feedback
|
|
kxbr=Compare and Signal (EB)
|
|
kxtr=Compare and Signal (ED)
|
|
l=Load (32)
|
|
la=Load Address
|
|
laa=Load and Add (32)
|
|
laag=Load and Add (64)
|
|
laal=Load and Add Logical (32)
|
|
laalg=Load and Add Logical (64)
|
|
lae=Load Address Extended
|
|
laey=Load Address Extended
|
|
lam=Load Access Multiple
|
|
lamy=Load Access Multiple
|
|
lan=Load and AND (32)
|
|
lang=Load and AND (64)
|
|
lao=Load and OR (32)
|
|
laog=Load and OR (64)
|
|
larl=Load Address Relative Long
|
|
lasp=Load Address Space Parameters
|
|
lat=Load and Trap (32)
|
|
lax=Load and Exclusive OR (32)
|
|
laxg=Load and Exclusive OR (64)
|
|
lay=Load Address
|
|
lb=Load Byte (32\8)
|
|
lbh=Load Byte High (32\8)
|
|
lbr=Load Byte (32\8)
|
|
lcbb=Load Count to Block Boundary
|
|
lcdbr=Load Complement (LB)
|
|
lcdfr=Load Complement (L)
|
|
lcdr=Load Complement (LH)
|
|
lcebr=Load Complement (SB)
|
|
lcer=Load Complement (SH)
|
|
lcgfr=Load Complement (64\32)
|
|
lcgr=Load Complement (64)
|
|
lcr=Load Complement (32)
|
|
lctl=Load Control (32)
|
|
lctlg=Load Control (64)
|
|
lcxbr=Load Complement (EB)
|
|
lcxr=Load Complement (EH)
|
|
ld=Load (L)
|
|
lde=Load Lengthened (LH\SH)
|
|
ldeb=Load Lengthened (LB\SB)
|
|
ldebr=Load Lengthened (LB\SB)
|
|
lder=Load Lengthened (LH\SH)
|
|
ldetr=Load Lengthened (LD\SD)
|
|
ldgr=Load FPR from GR (L\64)
|
|
ldr=Load (L)
|
|
ldxbr=Load Rounded (LB\EB)
|
|
ldxbra=Load Rounded (LB\EB)
|
|
ldxr=Load Rounded (LH\EH)
|
|
ldxtr=Load Rounded (LD\ED)
|
|
ldy=Load (L)
|
|
le=Load (S)
|
|
ledbr=Load Rounded (SB\LB)
|
|
ledbra=Load Rounded (SB\LB)
|
|
ledr=Load Rounded (SH\LH)
|
|
ledtr=Load Rounded (SD\LD)
|
|
ler=Load (S)
|
|
lexbr=Load Rounded (SB\EB)
|
|
lexbra=Load Rounded (SB\EB)
|
|
lexr=Load Rounded (SH\EH)
|
|
ley=Load (S)
|
|
lfas=Load FPC and Signal
|
|
lfh=Load High (32)
|
|
lfhat=Load and Trap (32H\32)
|
|
lfpc=Load FPC
|
|
lg=Load (64)
|
|
lgat=Load and Trap (64)
|
|
lgb=Load Byte (64\8)
|
|
lgbr=Load Byte (64\8)
|
|
lgdr=Load GR from FPR (64\L)
|
|
lgf=Load (64\32)
|
|
lgfi=Load Immediate (64\32)
|
|
lgfr=Load (64\32)
|
|
lgfrl=Load Relative Long (64\32)
|
|
lgh=Load Halfword (64\16)
|
|
lghi=Load Halfword Immediate (64\16)
|
|
lghr=Load Halfword (64\16)
|
|
lghrl=Load Halfword Relative Long (64\16)
|
|
lgr=Load (64)
|
|
lgrl=Load Relative Long (64)
|
|
lh=Load Halfword (32\16)
|
|
lhh=Load Halfword High (32\16)
|
|
lhi=Load Halfword Immediate (32\16)
|
|
lhr=Load Halfword (32\16)
|
|
lhrl=Load Halfword Relative Long (32\16)
|
|
lhy=Load Halfword (32\16)
|
|
llc=Load Logical Character (32\8)
|
|
llch=Load Logical Character High (32\8)
|
|
llcr=Load Logical Character (32\8)
|
|
llgc=Load Logical Character (64\8)
|
|
llgcr=Load Logical Character (64\8)
|
|
llgf=Load Logical (64\32)
|
|
llgfat=Load and Trap (64\32)
|
|
llgfr=Load Logical (64\32)
|
|
llgfrl=Load Logical Relative Long (64\32)
|
|
llgh=Load Logical Halfword (64\16)
|
|
llghr=Load Logical Halfword (64\16)
|
|
llghrl=Load Logical Halfword Relative Long
|
|
llgt=Load Logical Thirty One Bits (64\31)
|
|
llgtat=Load Logical Thirty One Bits and Trap
|
|
llgtr=Load Logical Thirty One Bits (64\31)
|
|
llh=Load Logical Halfword (32\16)
|
|
llhh=Load Logical Halfword High (32\16)
|
|
llhr=Load Logical Halfword (32\16)
|
|
llhrl=Load Logical Halfword Relative Long
|
|
llihf=Load Logical Immediate (high)
|
|
llihh=Load Logical Immediate (high high)
|
|
llihl=Load Logical Immediate (high low)
|
|
llilf=Load Logical Immediate (low)
|
|
llilh=Load Logical Immediate (low high)
|
|
llill=Load Logical Immediate (low low)
|
|
llzrgf=Load Logical and Zero Rightmost Byte (32)
|
|
lm=Load Multiple (32)
|
|
lmd=Load Multiple Disjoint (64\32&32)
|
|
lmg=Load Multiple (64)
|
|
lmh=Load Multiple High
|
|
lmy=Load Multiple (32)
|
|
lndbr=Load Negative (LB)
|
|
lndfr=Load Negative (L)
|
|
lndr=Load Negative (LH)
|
|
lnebr=Load Negative (SB)
|
|
lner=Load Negative (SH)
|
|
lngfr=Load Negative (64\32)
|
|
lngr=Load Negative (64)
|
|
lnr=Load Negative (32)
|
|
lnxbr=Load Negative (EB)
|
|
lnxr=Load Negative (EH)
|
|
loc=Load on Condition (32)
|
|
locfh=Load High on Condition (32)
|
|
locfhr=Load High on Condition (32)
|
|
locg=Load on Condition (64)
|
|
locghi=Load Halfword Immediate on Condition
|
|
locgr=Load on Condition (64)
|
|
lochhi=Load Halfword High Immediate on Condi-
|
|
lochi=Load Halfword Immediate on Condition
|
|
locr=Load on Condition (32)
|
|
lpd=Load Pair Disjoint (32)
|
|
lpdbr=Load Positive (LB)
|
|
lpdfr=Load Positive (L)
|
|
lpdg=Load Pair Disjoint (64)
|
|
lpdr=Load Positive (LH)
|
|
lpebr=Load Positive (SB)
|
|
lper=Load Positive (SH)
|
|
lpgfr=Load Positive (64\32)
|
|
lpgr=Load Positive (64)
|
|
lpq=Load Pair from Quadword (64&64\128)
|
|
lpr=Load Positive (32)
|
|
lpsw=Load PSW
|
|
lpswe=Load PSW Extended
|
|
lptea=Load Page-Table-Entry Address
|
|
lpxbr=Load Positive (EB)
|
|
lpxr=Load Positive (EH)
|
|
lr=Load (32)
|
|
lra=Load Real Address (32)
|
|
lrag=Load Real Address (64)
|
|
lray=Load Real Address (32)
|
|
lrdr=Load Rounded (LH\EH)
|
|
lrer=Load Rounded (SH\LH)
|
|
lrl=Load Relative Long (32)
|
|
lrv=Load Reversed (32)
|
|
lrvg=Load Reversed (64)
|
|
lrvgr=Load Reversed (64)
|
|
lrvh=Load Reversed (16)
|
|
lrvr=Load Reversed (32)
|
|
lt=Load and Test (32)
|
|
ltdbr=Load and Test (LB)
|
|
ltdr=Load and Test (LH)
|
|
ltdtr=Load and Test (LD)
|
|
ltebr=Load and Test (SB)
|
|
lter=Load and Test (SH)
|
|
ltg=Load and Test (64)
|
|
ltgf=Load And Test (64\32)
|
|
ltgfr=Load and Test (64\32)
|
|
ltgr=Load and Test (64)
|
|
ltr=Load and Test (32)
|
|
ltxbr=Load and Test (EB)
|
|
ltxr=Load and Test (EH)
|
|
ltxtr=Load and Test (ED)
|
|
lura=Load Using Real Address (32)
|
|
lurag=Load Using Real Address (64)
|
|
lxd=Load Lengthened (EH\LH)
|
|
lxdb=Load Lengthened (EB\LB)
|
|
lxdbr=Load Lengthened (EB\LB)
|
|
lxdr=Load Lengthened (EH\LH)
|
|
lxdtr=Load Lengthened (ED\LD)
|
|
lxe=Load Lengthened (EH\SH)
|
|
lxeb=Load Lengthened (EB\SB)
|
|
lxebr=Load Lengthened (EB\SB)
|
|
lxer=Load Lengthened (EH\SH)
|
|
lxr=Load (E)
|
|
ly=Load (32)
|
|
lzdr=Load Zero (L)
|
|
lzer=Load Zero (S)
|
|
lzrf=Load and Zero Rightmost Byte (32)
|
|
lzrg=Load and Zero Rightmost Byte (64)
|
|
lzxr=Load Zero (E)
|
|
m=Multiply (64\32)
|
|
mad=Multiply and Add (LH)
|
|
madb=Multiply and Add (LB)
|
|
madbr=Multiply and Add (LB)
|
|
madr=Multiply and Add (LH)
|
|
mae=Multiply and Add (SH)
|
|
maeb=Multiply and Add (SB)
|
|
maebr=Multiply and Add (SB)
|
|
maer=Multiply and Add (SH)
|
|
may=Multiply and Add Unnormalized (EH\LH)
|
|
mayh=Multiply and Add Unnormalized (EHH\LH)
|
|
mayhr=Multiply and Add Unnormalized (EHH\LH)
|
|
mayl=Multiply and Add Unnormalized (EHL\LH)
|
|
maylr=Multiply and Add Unnormalized (EHL\LH)
|
|
mayr=Multiply and Add Unnormalized (EH\LH)
|
|
mc=Monitor Call
|
|
md=Multiply (LH)
|
|
mdb=Multiply (LB)
|
|
mdbr=Multiply (LB)
|
|
mde=Multiply (LH\SH)
|
|
mdeb=Multiply (LB\SB)
|
|
mdebr=Multiply (LB\SB)
|
|
mder=Multiply (LH\SH)
|
|
mdr=Multiply (LH)
|
|
mdtr=Multiply (LD)
|
|
mdtra=Multiply (LD)
|
|
me=Multiply (LH\SH)
|
|
mee=Multiply (SH)
|
|
meeb=Multiply (SB)
|
|
meebr=Multiply (SB)
|
|
meer=Multiply (SH)
|
|
mer=Multiply (LH\SH)
|
|
mfy=Multiply (64\32)
|
|
mghi=Multiply Halfword Immediate (64\16)
|
|
mh=Multiply Halfword (32\16)
|
|
mhi=Multiply Halfword Immediate (32\16)
|
|
mhy=Multiply Halfword (64\16)
|
|
ml=Multiply Logical (64\32)
|
|
mlg=Multiply Logical (128\64)
|
|
mlgr=Multiply Logical (128\64)
|
|
mlr=Multiply Logical (64\32)
|
|
mp=Multiply Decimal
|
|
mr=Multiply (64\32)
|
|
ms=Multiply Single (32)
|
|
msch=Modify Subchannel
|
|
msd=Multiply and Subtract (LH)
|
|
msdb=Multiply and Subtract (LB)
|
|
msdbr=Multiply and Subtract (LB)
|
|
msdr=Multiply and Subtract (LH)
|
|
mse=Multiply and Subtract (SH)
|
|
mseb=Multiply and Subtract (SB)
|
|
msebr=Multiply and Subtract (SB)
|
|
mser=Multiply and Subtract (SH)
|
|
msfi=Multiply Single Immediate (32)
|
|
msg=Multiply Single (64)
|
|
msgf=Multiply Single (64\32)
|
|
msgfi=Multiply Single Immediate (64\32)
|
|
msgfr=Multiply Single (64\32)
|
|
msgr=Multiply Single (64)
|
|
msr=Multiply Single (32)
|
|
msta=Modify Stacked State
|
|
msy=Multiply Single (32)
|
|
mvc=Move (character)
|
|
mvcdk=Move with Destination Key
|
|
mvcin=Move Inverse
|
|
mvck=Move with Key
|
|
mvcl=Move Long
|
|
mvcle=Move Long Extended
|
|
mvclu=Move Long Unicode
|
|
mvcos=Move with Optional Specifications
|
|
mvcp=Move to Primary
|
|
mvcs=Move to Secondary
|
|
mvcsk=Move with Source Key
|
|
mvghi=Move (64\16)
|
|
mvhhi=Move (16\16)
|
|
mvhi=Move (32\16)
|
|
mvi=Move Immediate
|
|
mviy=Move Immediate
|
|
mvn=Move Numerics
|
|
mvo=Move with Offset
|
|
mvpg=Move Page
|
|
mvst=Move String
|
|
mvz=Move Zones
|
|
mxbr=Multiply (EB)
|
|
mxd=Multiply (EH\LH)
|
|
mxdb=Multiply (EB\LB)
|
|
mxdbr=Multiply (EB\LB)
|
|
mxdr=Multiply (EH\LH)
|
|
mxr=Multiply (EH)
|
|
mxtr=Multiply (ED)
|
|
mxtra=Multiply (ED)
|
|
my=Multiply Unnormalized (EH\LH)
|
|
myh=Multiply Unnormalized (EHH\LH)
|
|
myhr=Multiply Unnormalized (EHH\LH)
|
|
myl=Multiply Unnormalized (EHL\LH)
|
|
mylr=Multiply Unnormalized (EHL\LH)
|
|
myr=Multiply Unnormalized (EH\LH)
|
|
n=AND (32)
|
|
nc=AND (character)
|
|
ng=AND (64)
|
|
ngr=AND (64)
|
|
ngrk=AND (64)
|
|
ni=AND Immediate
|
|
niai=Next Instruction Access Intent
|
|
nihf=AND Immediate (high)
|
|
nihh=AND Immediate (high high)
|
|
nihl=AND Immediate (high low)
|
|
nilf=AND Immediate (low)
|
|
nilh=AND Immediate (low high)
|
|
nill=AND Immediate (low low)
|
|
niy=AND Immediate
|
|
nr=AND (32)
|
|
nrk=AND (32)
|
|
ntstg=Nontransactional Store (64)
|
|
ny=AND (32)
|
|
o=OR (32)
|
|
oc=OR (character)
|
|
og=OR (64)
|
|
ogr=OR (64)
|
|
ogrk=OR (64)
|
|
oi=OR Immediate
|
|
oihf=OR Immediate (high)
|
|
oihh=OR Immediate (high high)
|
|
oihl=OR Immediate (high low)
|
|
oilf=OR Immediate (low)
|
|
oilh=OR Immediate (low high)
|
|
oill=OR Immediate (low low)
|
|
oiy=OR Immediate
|
|
or=OR (32)
|
|
ork=OR (32)
|
|
oy=OR (32)
|
|
pack=Pack
|
|
palb=Purge ALB
|
|
pc=Program Call
|
|
pcc=Perform Cryptographic Computation
|
|
pckmo=Perform Crypto. Key Mgmt. Operations
|
|
pfd=Prefetch Data
|
|
pfdrl=Prefetch Data Relative Long
|
|
pfmf=Perform Frame Management Function
|
|
pfpo=Perform Floating-Point Operation
|
|
pgin=Page In
|
|
pgout=Page Out
|
|
pka=Pack ASCII
|
|
pku=Pack Unicode
|
|
plo=Perform Locked Operation
|
|
popcnt=Population Count
|
|
ppa=Perform Processor Assist
|
|
ppno=Perform Pseudorandom Number Operation
|
|
pr=Program Return
|
|
pt=Program Transfer
|
|
ptf=Perform Topology Function
|
|
ptff=Perform Timing-Facility Function
|
|
pti=Program Transfer with Instance
|
|
ptlb=Purge TLB
|
|
qadtr=Quantize (LD)
|
|
qaxtr=Quantize (ED)
|
|
rchp=Reset Channel Path
|
|
risbg=Rotate then Insert Selected Bits (64)
|
|
risbgn=Rotate then Insert Selected Bits (64)
|
|
risbhg=Rotate then Insert Selected Bits High32)
|
|
risblg=Rotate then Insert Selected Bits Low 2)
|
|
rll=Rotate Left Single Logical (32)
|
|
rllg=Rotate Left Single Logical (64)
|
|
rnsbg=Rotate then AND Selected Bits (64)
|
|
rosbg=Rotate then OR Selected Bits (64)
|
|
rp=Resume Program
|
|
rrbe=Reset Reference Bit Extended
|
|
rrbm=Reset Reference Bits Multiple
|
|
rrdtr=Reround (LD)
|
|
rrxtr=Reround (ED)
|
|
rsch=Resume Subchannel
|
|
rxsbg=Rotate then Exclusive OR Selected Bit
|
|
s=Subtract (32)
|
|
sac=Set Address Space Control
|
|
sacf=Set Address Space Control Fast
|
|
sal=Set Address Limit
|
|
sam24=Set Addressing Mode (24)
|
|
sam31=Set Addressing Mode (31)
|
|
sam64=Set Addressing Mode (64)
|
|
sar=Set Access
|
|
schm=Set Channel Monitor
|
|
sck=Set Clock
|
|
sckc=Set Clock Comparator
|
|
sckpf=Set Clock Programmable Field
|
|
sd=Subtract Normalized (LH)
|
|
sdb=Subtract (LB)
|
|
sdbr=Subtract (LB)
|
|
sdr=Subtract Normalized (LH)
|
|
sdtr=Subtract (LD)
|
|
sdtra=Subtract (LD)
|
|
se=Subtract Normalized (SH)
|
|
seb=Subtract (SB)
|
|
sebr=Subtract (SB)
|
|
ser=Subtract Normalized (SH)
|
|
sfasr=Set FPC and Signal
|
|
sfpc=Set FPC
|
|
sg=Subtract (64)
|
|
sgf=Subtract (64\32)
|
|
sgfr=Subtract (64\32)
|
|
sgr=Subtract (64)
|
|
sgrk=Subtract (64)
|
|
sh=Subtract Halfword (32\16)
|
|
shhhr=Subtract High (32)
|
|
shhlr=Subtract High (32)
|
|
shy=Subtract Halfword (32\16)
|
|
sie=Start Interpretive Execution
|
|
sigp=Signal Processor
|
|
sl=Subtract Logical (32)
|
|
sla=Shift Left Single (32)
|
|
slag=Shift Left Single (64)
|
|
slak=Shift Left Single (32)
|
|
slb=Subtract Logical with Borrow (32)
|
|
slbg=Subtract Logical with Borrow (64)
|
|
slbgr=Subtract Logical with Borrow (64)
|
|
slbr=Subtract Logical with Borrow (32)
|
|
slda=Shift Left Double (64)
|
|
sldl=Shift Left Double Logical (64)
|
|
sldt=Shift Significand Left (LD)
|
|
slfi=Subtract Logical Immediate (32)
|
|
slg=Subtract Logical (64)
|
|
slgf=Subtract Logical (64\32)
|
|
slgfi=Subtract Logical Immediate (64\32)
|
|
slgfr=Subtract Logical (64\32)
|
|
slgr=Subtract Logical (64)
|
|
slgrk=Subtract Logical (64)
|
|
slhhhr=Subtract Logical High (32)
|
|
slhhlr=Subtract Logical High (32)
|
|
sll=Shift Left Single Logical (32)
|
|
sllg=Shift Left Single Logical (64)
|
|
sllk=Shift Left Single Logical (32)
|
|
slr=Subtract Logical (32)
|
|
slrk=Subtract Logical (32)
|
|
slxt=Shift Significand Left (ED)
|
|
sly=Subtract Logical (32)
|
|
sp=Subtract Decimal
|
|
spka=Set PSW Key from Address
|
|
spm=Set Program Mask
|
|
spt=Set CPU Timer
|
|
spx=Set Prefix
|
|
sqd=Square Root (LH)
|
|
sqdb=Square Root (LB)
|
|
sqdbr=Square Root (LB)
|
|
sqdr=Square Root (LH)
|
|
sqe=Square Root (SH)
|
|
sqeb=Square Root (SB)
|
|
sqebr=Square Root (SB)
|
|
sqer=Square Root (SH)
|
|
sqxbr=Square Root (EB)
|
|
sqxr=Square Root (EH)
|
|
sr=Subtract (32)
|
|
sra=Shift Right Single (32)
|
|
srag=Shift Right Single (64)
|
|
srak=Shift Right Single (32)
|
|
srda=Shift Right Double (64)
|
|
srdl=Shift Right Double Logical (64)
|
|
srdt=Shift Significand Right (LD)
|
|
srk=Subtract (32)
|
|
srl=Shift Right Single Logical (32)
|
|
srlg=Shift Right Single Logical (64)
|
|
srlk=Shift Right Single Logical (32)
|
|
srnm=Set BFP Rounding Mode (2 bit)
|
|
srnmb=Set BFP Rounding Mode (3 bit)
|
|
srnmt=Set DFP Rounding Mode
|
|
srp=Shift and Round Decimal
|
|
srst=Search String
|
|
srstu=Search String Unicode
|
|
srxt=Shift Significand Right (ED)
|
|
ssair=Set Secondary ASN with Instance
|
|
ssar=Set Secondary ASN
|
|
ssch=Start Subchannel
|
|
sske=Set Storage Key Extended
|
|
ssm=Set System Mask
|
|
st=Store (32)
|
|
stam=Store Access Multiple
|
|
stamy=Store Access Multiple
|
|
stap=Store CPU Address
|
|
stc=Store Character
|
|
stch=Store Character High (8)
|
|
stck=Store Clock
|
|
stckc=Store Clock Comparator
|
|
stcke=Store Clock Extended
|
|
stckf=Store Clock Fast
|
|
stcm=Store Characters under Mask (low)
|
|
stcmh=Store Characters under Mask (high)
|
|
stcmy=Store Characters under Mask (low)
|
|
stcps=Store Channel Path Status
|
|
stcrw=Store Channel Report Word
|
|
stctg=Store Control (64)
|
|
stctl=Store Control (32)
|
|
stcy=Store Character
|
|
std=Store (L)
|
|
stdy=Store (L)
|
|
ste=Store (S)
|
|
stey=Store (S)
|
|
stfh=Store High (32)
|
|
stfl=Store Facility List
|
|
stfle=Store Facility List Extended
|
|
stfpc=Store FPC
|
|
stg=Store (64)
|
|
stgrl=Store Relative Long (64)
|
|
sth=Store Halfword (16)
|
|
sthh=Store Halfword High (16)
|
|
sthrl=Store Halfword Relative Long (16)
|
|
sthy=Store Halfword (16)
|
|
stidp=Store CPU ID
|
|
stm=Store Multiple (32)
|
|
stmg=Store Multiple (64)
|
|
stmh=Store Multiple High (32)
|
|
stmy=Store Multiple (32)
|
|
stnsm=Store Then And System Mask
|
|
stoc=Store on Condition (32)
|
|
stocfh=Store High on Condition (32)
|
|
stocg=Store on Condition (64)
|
|
stosm=Store Then Or System Mask
|
|
stpq=Store Pair to Quadword (64,64\128)
|
|
stpt=Store CPU Timer
|
|
stpx=Store Prefix
|
|
strag=Store Real Address (64)
|
|
strl=Store Relative Long (32)
|
|
strv=Store Reversed (32)
|
|
strvg=Store Reversed (64)
|
|
strvh=Store Reversed (16)
|
|
stsch=Store Subchannel
|
|
stsi=Store System Information
|
|
stura=Store Using Real Address (32)
|
|
sturg=Store Using Real Address (64)
|
|
sty=Store (32)
|
|
su=Subtract Unnormalized (SH)
|
|
sur=Subtract Unnormalized (SH)
|
|
svc=Supervisor Call
|
|
sw=Subtract Unnormalized (LH)
|
|
swr=Subtract Unnormalized (LH)
|
|
sxbr=Subtract (EB)
|
|
sxr=Subtract Normalized (EH)
|
|
sxtr=Subtract (ED)
|
|
sxtra=Subtract (ED)
|
|
sy=Subtract (32)
|
|
tabort=Transaction Abort
|
|
tam=Test Addressing Mode
|
|
tar=Test Access
|
|
tb=Test Block
|
|
tbdr=Convert HFP to BFP (LB\LH)
|
|
tbedr=Convert HFP to BFP (SB\LH)
|
|
tbegin=Transaction Begin (nonconstrained)
|
|
tbeginc=Transaction Begin (constrained)
|
|
tcdb=Test Data Class (LB)
|
|
tceb=Test Data Class (SB)
|
|
tcxb=Test Data Class (EB)
|
|
tdcdt=Test Data Class (LD)
|
|
tdcet=Test Data Class (SD)
|
|
tdcxt=Test Data Class (ED)
|
|
tdgdt=Test Data Group (LD)
|
|
tdget=Test Data Group (SD)
|
|
tdgxt=Test Data Group (ED)
|
|
tend=Transaction End
|
|
thder=Convert BFP to HFP (LH\SB)
|
|
thdr=Convert BFP to HFP (LH\LB)
|
|
tm=Test under Mask
|
|
tmh=Test under Mask High
|
|
tmhh=Test under Mask (high high)
|
|
tmhl=Test under Mask (high low)
|
|
tml=Test under Mask Low
|
|
tmlh=Test under Mask (low high)
|
|
tmll=Test under Mask (low low)
|
|
tmy=Test under Mask
|
|
tp=Test Decimal
|
|
tpi=Test Pending Interruption
|
|
tprot=Test Protection
|
|
tr=Translate
|
|
trace=Trace (32)
|
|
tracg=Trace (64)
|
|
trap2=Trap
|
|
trap4=Trap
|
|
tre=Translate Extended
|
|
troo=Translate One to One
|
|
trot=Translate One to Two
|
|
trt=Translate and Test
|
|
trte=Translate and Test Extended
|
|
trto=Translate Two to One
|
|
trtr=Translate and Test Reverse
|
|
trtre=Translate and Test Reverse Extended
|
|
trtt=Translate Two to Two
|
|
ts=Test and Set
|
|
tsch=Test Subchannel
|
|
unpk=Unpack
|
|
unpka=Unpack ASCII
|
|
unpku=Unpack Unicode
|
|
upt=Update Tree
|
|
va=Vector Add
|
|
vac=Vector Add With Carry
|
|
vacc=Vector Add Compute Carry
|
|
vaccc=Vector Add With Carry Compute Carry
|
|
vavg=Vector Average
|
|
vavgl=Vector Average Logical
|
|
vcdg=Vector FP Convert from Fixed 64-bit
|
|
vcdlg=Vector FP Convert from Logical 64-bit
|
|
vceq=Vector Compare Equal
|
|
vcgd=Vector FP Convert to Fixed 64-bit
|
|
vch=Vector Compare High
|
|
vchl=Vector Compare High Logical
|
|
vcksm=Vector Checksum
|
|
vclgd=Vector FP Convert to Logical 64-bit
|
|
vclz=Vector Count Leading Zeros
|
|
vctz=Vector Count Trailing Zeros
|
|
vec=Vector Element Compare
|
|
vecl=Vector Element Compare Logical
|
|
verim=Vector Element Rotate and Insert Under
|
|
verll=Vector Element Rotate Left Logical
|
|
verllv=Vector Element Rotate Left Logical
|
|
vesl=Vector Element Shift Left
|
|
veslv=Vector Element Shift Left
|
|
vesra=Vector Element Shift Right Arithmetic
|
|
vesrav=Vector Element Shift Right Arithmetic
|
|
vesrl=Vector Element Shift Right Logical
|
|
vesrlv=Vector Element Shift Right Logical
|
|
vfa=Vector FP Add
|
|
vfae=Vector Find Any Element Equal
|
|
vfce=Vector FP Compare Equal
|
|
vfch=Vector FP Compare High
|
|
vfche=Vector FP Compare High or Equal
|
|
vfd=Vector FP Divide
|
|
vfee=Vector Find Element Equal
|
|
vfene=Vector Find Element Not Equal
|
|
vfi=Vector Load FP Integer
|
|
vfm=Vector FP Multiply
|
|
vfma=Vector FP Multiply and Add
|
|
vfms=Vector FP Multiply and Subtract
|
|
vfpso=Vector FP Perform Sign Operation
|
|
vfs=Vector FP Subtract
|
|
vfsq=Vector FP Square Root
|
|
vftci=Vector FP Test Data Class Immediate
|
|
vgbm=Vector Generate Byte Mask
|
|
vgef=Vector Gather Element (32)
|
|
vgeg=Vector Gather Element (64)
|
|
vgfm=Vector Galois Field Multiply Sum
|
|
vgfma=Vector Galois Field Multiply Sum and
|
|
vgm=Vector Generate Mask
|
|
vistr=Vector Isolate String
|
|
vl=Vector Load
|
|
vlbb=Vector Load to Block Boundary
|
|
vlc=Vector Load Complement
|
|
vlde=Vector FP Load Lengthened
|
|
vleb=Vector Load Element (8)
|
|
vled=Vector FP Load Rounded
|
|
vlef=Vector Load Element (32)
|
|
vleg=Vector Load Element (64)
|
|
vleh=Vector Load Element (16)
|
|
vleib=Vector Load Element Immediate (8)
|
|
vleif=Vector Load Element Immediate (32)
|
|
vleig=Vector Load Element Immediate (64)
|
|
vleih=Vector Load Element Immediate (16)
|
|
vlgv=Vector Load GR from VR Element
|
|
vll=Vector Load With Length
|
|
vllez=Vector Load Logical Element and Zero
|
|
vlm=Vector Load Multiple
|
|
vlp=Vector Load Positive
|
|
vlr=Vector Load
|
|
vlrep=Vector Load and Replicate
|
|
vlvg=Vector Load VR Element from GR
|
|
vlvgp=Vector Load VR from GRs Disjoint
|
|
vmae=Vector Multiply and Add Even
|
|
vmah=Vector Multiply and Add High
|
|
vmal=Vector Multiply and Add Low
|
|
vmale=Vector Multiply and Add Logical Even
|
|
vmalh=Vector Multiply and Add Logical High
|
|
vmalo=Vector Multiply and Add Logical Odd
|
|
vmao=Vector Multiply and Add Odd
|
|
vme=Vector Multiply Even
|
|
vmh=Vector Multiply High
|
|
vml=Vector Multiply Low
|
|
vmle=Vector Multiply Logical Even
|
|
vmlh=Vector Multiply Logical High
|
|
vmlo=Vector Multiply Logical Odd
|
|
vmn=Vector Minimum
|
|
vmnl=Vector Minimum Logical
|
|
vmo=Vector Multiply Odd
|
|
vmrh=Vector Merge High
|
|
vmrl=Vector Merge Low
|
|
vmx=Vector Maximum
|
|
vmxl=Vector Maximum Logical
|
|
vn=Vector AND
|
|
vnc=Vector AND with Complement
|
|
vno=Vector NOR
|
|
vo=Vector OR
|
|
vpdi=Vector Permute Doubleword Immediate
|
|
vperm=Vector Permute
|
|
vpk=Vector Pack
|
|
vpkls=Vector Pack Logical Saturate
|
|
vpks=Vector Pack Saturate
|
|
vpopct=Vector Population Count
|
|
vrep=Vector Replicate
|
|
vrepi=Vector Replicate Immediate
|
|
vs=Vector Subtract
|
|
vsbcbi=Vector Subtract With Borrow Compute
|
|
vsbi=Vector Subtract With Borrow Indication
|
|
vscbi=Vector Subtract Compute Borrow Indication
|
|
vscef=Vector Scatter Element (32)
|
|
vsceg=Vector Scatter Element (64)
|
|
vseg=Vector Sign Extend to Doubleword
|
|
vsel=Vector Select
|
|
vsl=Vector Shift Left
|
|
vslb=Vector Shift Left By Byte
|
|
vsldb=Vector Shift Left Double By Byte
|
|
vsra=Vector Shift Right Arithmetic
|
|
vsrab=Vector Shift Right Arithmetic By Byte
|
|
vsrl=Vector Shift Right Logical
|
|
vsrlb=Vector Shift Right Logical By Byte
|
|
vst=Vector Store
|
|
vsteb=Vector Store Element (8)
|
|
vstef=Vector Store Element (32)
|
|
vsteg=Vector Store Element (64)
|
|
vsteh=Vector Store Element (16)
|
|
vstl=Vector Store With Length
|
|
vstm=Vector Store Multiple
|
|
vstrc=Vector String Range Compare
|
|
vsum=Vector Sum Across Word
|
|
vsumg=Vector Sum Across Doubleword
|
|
vsumq=Vector Sum Across Quadword
|
|
vtm=Vector Test Under Mask
|
|
vuph=Vector Unpack High
|
|
vupl=Vector Unpack Low
|
|
vuplh=Vector Unpack Logical High
|
|
vupll=Vector Unpack Logical Low
|
|
vx=Vector Exclusive OR
|
|
wfc=Vector FP Compare Scalar
|
|
wfk=Vector FP Compare and Signal Scalar
|
|
x=Exclusive OR (32)
|
|
xc=Exclusive OR (character)
|
|
xg=Exclusive OR (64)
|
|
xgr=Exclusive OR (64)
|
|
xgrk=Exclusive OR (64)
|
|
xi=Exclusive OR Immediate
|
|
xihf=Exclusive OR Immediate (high)
|
|
xilf=Exclusive OR Immediate (low)
|
|
xiy=Exclusive OR Immediate
|
|
xr=Exclusive OR (32)
|
|
xrk=Exclusive OR (32)
|
|
xsch=Cancel Subchannel
|
|
xy=Exclusive Or (32)
|
|
zap=Zero and Add
|