mirror of
https://github.com/Zenithsiz/ftmemsim-valgrind.git
synced 2026-02-08 04:55:52 +00:00
f1a49eeb42
(from bug 385408 comment 0): Valgrind currently lacks support for the z/Architecture vector "support" instructions introduced with z13. These are documented in the z/Architecture Principles of Operation, Eleventh Edition (March, 2015), chapter 21: "Vector Overview and Support Instructions".
1672 lines
91 KiB
CSV
1672 lines
91 KiB
CSV
a,add,implemented,
|
|
ad,"add normalized (long)","won't do","hfp instruction"
|
|
adr,"add normalized (long)","won't do","hfp instruction"
|
|
ae,"add normalized (short)","won't do","hfp instruction"
|
|
aer,"add normalized (short)","won't do","hfp instruction"
|
|
ah,"add halfword",implemented,
|
|
al,"add logical",implemented,
|
|
alr,"add logical",implemented,
|
|
ap,"add decimal","not implemented",
|
|
ar,add,implemented,
|
|
au,"add unnormalized (short)","won't do","hfp instruction"
|
|
aur,"add unnormalized (short)","won't do","hfp instruction"
|
|
aw,"add unnormalized (long)","won't do","hfp instruction"
|
|
awr,"add unnormalized (long)","won't do","hfp instruction"
|
|
axr,"add normalized","won't do","hfp instruction"
|
|
bakr,"branch and stack","not implemented",
|
|
bal,"branch and link","not implemented",
|
|
balr,"branch and link","not implemented",
|
|
bas,"branch and save",implemented,
|
|
basr,"branch and save",implemented,
|
|
bassm,"branch and save and set mode","not implemented",
|
|
bc,"branch on condition",implemented,
|
|
bcr,"branch on condition",implemented,
|
|
bct,"branch on count",implemented,
|
|
bctr,"branch on count",implemented,
|
|
bsg,"branch in subspace group","not implemented",
|
|
bsm,"branch and set mode","not implemented",
|
|
bxh,"branch on index high",implemented,
|
|
bxle,"branch on index low or equal",implemented,
|
|
c,compare,implemented,
|
|
cd,"compare (long)","won't do","hfp instruction"
|
|
cdr,"compare (long)","won't do","hfp instruction"
|
|
cds,"compare double and swap",implemented,
|
|
ce,"compare (short)","won't do","hfp instruction"
|
|
cer,"compare (short)","won't do","hfp instruction"
|
|
cfc,"compare and form codeword","not implemented",
|
|
ch,"compare halfword",implemented,
|
|
cl,"compare logical",implemented,
|
|
clc,"compare logical",implemented,
|
|
clcl,"compare logical long",implemented,
|
|
cli,"compare logical",implemented,
|
|
clm,"compare logical characters under mask",implemented,
|
|
clr,"compare logical",implemented,
|
|
clst,"compare logical string",implemented,
|
|
cp,"compare decimal","not implemented",
|
|
cpya,"copy access",implemented,
|
|
cr,compare,implemented,
|
|
cs,"compare and swap",implemented,
|
|
csch,"clear subchannel",N/A,"privileged instruction"
|
|
cuse,"compare until substring equal","not implemented",
|
|
csp,"compare and swap and purge",N/A,"privileged instruction"
|
|
cvb,"convert to binary",implemented,
|
|
cvd,"convert to decimal",implemented,
|
|
cxr,"compare extended hfp","won't do","hfp instruction"
|
|
d,divide,implemented,
|
|
dd,"divide (long)","won't do","hfp instruction"
|
|
ddr,"divide (long)","won't do","hfp instruction"
|
|
de,"divide (short)","won't do","hfp instruction"
|
|
der,"divide (short)","won't do","hfp instruction"
|
|
diag,diagnose,N/A,"privileged instruction"
|
|
dp,"divide decimal","not implemented",
|
|
dr,divide,implemented,
|
|
dxr,"divide (ext.)","won't do","hfp instruction"
|
|
ear,"extract access",implemented,
|
|
ed,edit,"not implemented",
|
|
edmk,"edit and mark","not implemented",
|
|
epar,"extract primary ASN",N/A,"privileged instruction"
|
|
epair,"extract primary ASN and instance",N/A,"privileged instruction"
|
|
ereg,"extract stacked registers","not implemented",
|
|
esar,"extract secondary ASN",N/A,"privileged instruction",
|
|
esair,"extract secondary ASN and instance",N/A,"privileged instruction",
|
|
esta,"extract stacked state","not implemented",
|
|
ex,execute,implemented,
|
|
hdr,"halve (long)","won't do","hfp instruction"
|
|
her,"halve (short)","won't do","hfp instruction"
|
|
hsch,"halt subchannel",N/A,"privileged instruction"
|
|
iac,"insert address space control",N/A,"privileged instruction"
|
|
ic,"insert character",implemented,
|
|
icm,"insert characters under mask",implemented,
|
|
ipk,"insert PSW key",N/A,"privileged instruction"
|
|
ipm,"insert program mask",implemented,
|
|
ipte,"invalidate page table entry",N/A,"privileged instruction"
|
|
iske,"insert storage key extended",N/A,"privileged instruction"
|
|
ivsk,"insert virtual storage key",N/A,"privileged instruction"
|
|
l,load,implemented,
|
|
la,"load address",implemented,
|
|
lae,"load address extended",implemented,
|
|
lam,"load access multiple",implemented,
|
|
lasp,"load address space parameters",N/A,"privileged instruction"
|
|
lcdr,"load complement (long)","won't do","hfp instruction"
|
|
lcer,"load complement (short)","won't do","hfp instruction"
|
|
lcr,"load complement",implemented,
|
|
lctl,"load control",N/A,"privileged instruction"
|
|
ld,"load (long)",implemented,
|
|
ldr,"load (long)",implemented,
|
|
le,"load (short)",implemented,
|
|
ler,"load (short)",implemented,
|
|
lh,"load halfword",implemented,
|
|
lm,"load multiple",implemented,
|
|
lndr,"load negative (long)","won't do","hfp instruction"
|
|
lner,"load negative (short)","won't do","hfp instruction"
|
|
lnr,"load negative",implemented,
|
|
lpdr,"load positive (long)","won't do","hfp instruction"
|
|
lper,"load positive (short)","won't do","hfp instruction"
|
|
lpr,"load positive",implemented,
|
|
lpsw,"load PSW",N/A,"privileged instruction"
|
|
lr,load,implemented,
|
|
lra,"load real address",N/A,"privileged instruction"
|
|
ldxr,"load rounded (ext. to long)","won't do","hfp instruction"
|
|
ledr,"load rounded (long to short)","won't do","hfp instruction"
|
|
ltdr,"load and test (long)","won't do","hfp instruction"
|
|
lter,"load and test (short)","won't do","hfp instruction"
|
|
ltr,"load and test",implemented,
|
|
lura,"load using real address",N/A,"privileged instruction"
|
|
m,multiply,implemented,
|
|
mc,"monitor call","not implemented",
|
|
md,"multiply (long)","won't do","hfp instruction"
|
|
mdr,"multiply (long)","won't do","hfp instruction"
|
|
mde,"multiply (short to long)","won't do","hfp instruction"
|
|
mder,"multiply short to long hfp","won't do","hfp instruction"
|
|
mh,"multiply halfword",implemented,
|
|
mp,"multiply decimal","not implemented",
|
|
mr,multiply,implemented,
|
|
msch,"modify subchannel",N/A,"privileged instruction"
|
|
msta,"modify stacked state","not implemented",
|
|
mvc,move,implemented,
|
|
mvcdk,"move with destination key",N/A,"privileged instruction"
|
|
mvcin,"move inverse",implemented,
|
|
mvck,"move with key",N/A,"privileged instruction"
|
|
mvcl,"move long",implemented,
|
|
mvcp,"move to primary",N/A,"privileged instruction"
|
|
mvcs,"move to secondary",N/A,"privileged instruction"
|
|
mvcsk,"move with source key","not implemented",
|
|
mvi,move,implemented,
|
|
mvn,"move numerics","not implemented",
|
|
mvo,"move with offset","not implemented",
|
|
mvpg,"move page",N/A,"privileged instruction"
|
|
mvst,"move string",implemented,
|
|
mvz,"move zones","not implemented",
|
|
mxd,"multiply (long to ext.)","won't do","hfp instruction"
|
|
mxdr,"multiply (long to ext.)","won't do","hfp instruction"
|
|
mxr,"multiply (ext.)","won't do","hfp instruction"
|
|
n,AND,implemented,
|
|
nc,AND,implemented,
|
|
ni,AND,implemented,
|
|
nr,AND,implemented,
|
|
o,OR,implemented,
|
|
oc,OR,implemented,
|
|
oi,OR,implemented,
|
|
or,OR,implemented,
|
|
pack,pack,"not implemented",
|
|
palb,"purge ALB",N/A,"privileged instruction"
|
|
pc,"program call",N/A,"privileged instruction"
|
|
pr,"program return","not implemented",
|
|
pt,"program transfer",N/A,"privileged instruction",
|
|
pti,"program transfer with instance",N/A,"privileged instruction",
|
|
ptlb,"purge TLB",N/A,"privileged instruction"
|
|
rchp,"reset channel path",N/A,"privileged instruction"
|
|
rrbe,"reset reference bit extended",N/A,"privileged instruction"
|
|
rsch,"resume subchannel",N/A,"privileged instruction"
|
|
s,subtract,implemented,
|
|
sac,"set address space control",N/A,"privileged instruction"
|
|
sacf,"set address space control fast",N/A,"privileged instruction"
|
|
sal,"set address limit",N/A,"privileged instruction"
|
|
sar,"set access",implemented,
|
|
schm,"set channel monitor",N/A,"privileged instruction"
|
|
sck,"set clock",N/A,"privileged instruction"
|
|
sckc,"set clock comparator",N/A,"privileged instruction"
|
|
sd,"subtract normalized (long)","won't do","hfp instruction"
|
|
sdr,"subtract normalized (long)","won't do","hfp instruction"
|
|
se,"subtract normalized (short)","won't do","hfp instruction"
|
|
ser,"subtract normalized (short)","won't do","hfp instruction"
|
|
sh,"subtract halfword",implemented,
|
|
sie,"start interpretive execution","not implemented",
|
|
sigp,"signal processor",N/A,"privileged instruction"
|
|
sl,"subtract logical",implemented,
|
|
sla,"shift left single",implemented,
|
|
slda,"shift left double (long)",implemented,
|
|
sldl,"shift left double logical (long)",implemented,
|
|
sll,"shift left single logical",implemented,
|
|
slr,"subtract logical",implemented,
|
|
sp,"subtract decimal","not implemented",
|
|
spka,"set PSW key from address",N/A,"privileged instruction"
|
|
spm,"set program mask","not implemented",
|
|
spt,"set CPU timer",N/A,"privileged instruction"
|
|
spx,"set prefix",N/A,"privileged instruction"
|
|
sqdr,"square root (long)","won't do","hfp instruction"
|
|
sqer,"square root (short)","won't do","hfp instruction"
|
|
sr,subtract,implemented,
|
|
sra,"shift right single",implemented,
|
|
srda,"shift right double (long)",implemented,
|
|
srdl,"shift right double logical (long)",implemented,
|
|
srl,"shift right single logical",implemented,
|
|
srp,"shift and round decimal","not implemented",
|
|
srst,"search string",implemented,
|
|
ssar,"set secondary ASN","not implemented",
|
|
ssair,"set secondary ASN with instance","not implemented",
|
|
ssch,"start subchannel",N/A,"privileged instruction"
|
|
sske,"set storage key extended",N/A,"privileged instruction"
|
|
ssm,"set system mask",N/A,"privileged instruction"
|
|
st,store,implemented,
|
|
stam,"store access multiple",implemented,
|
|
stap,"store CPU address",N/A,"privileged instruction"
|
|
stc,"store character",implemented,
|
|
stck,"store clock",implemented,
|
|
stckc,"store clock comparator",N/A,"privileged instruction"
|
|
stcm,"store characters under mask",implemented,
|
|
stcps,"store channel path status",N/A,"privileged instruction"
|
|
stcrw,"store channel report word",N/A,"privileged instruction"
|
|
stctl,"store control",N/A,"privileged instruction"
|
|
std,"store (long)",implemented,
|
|
ste,"store (short)",implemented,
|
|
sth,"store halfword",implemented,
|
|
stidp,"store CPU id",N/A,"privileged instruction"
|
|
stm,"store multiple",implemented,
|
|
stnsm,"store then AND system mask",N/A,"privileged instruction"
|
|
stosm,"store then OR system mask",N/A,"privileged instruction"
|
|
stpt,"store CPU timer",N/A,"privileged instruction"
|
|
stpx,"store prefix",N/A,"privileged instruction"
|
|
stsch,"store subchannel",N/A,"privileged instruction"
|
|
stura,"store using real address",N/A,"privileged instruction"
|
|
su,"subtract unnormalized (short)","won't do","hfp instruction"
|
|
sur,"subtract unnormalized (short)","won't do","hfp instruction"
|
|
svc,"supervisor call",implemented,
|
|
sw,"subtract unnormalized (long)","won't do","hfp instruction"
|
|
swr,"subtract unnormalized (long)","won't do","hfp instruction"
|
|
sxr,"subtract normalized (ext.)","won't do","hfp instruction"
|
|
tar,"test access","not implemented",
|
|
tb,"test block",N/A,"privileged instruction"
|
|
tm,"test under mask",implemented,
|
|
tpi,"test pending interruption",N/A,"privileged instruction"
|
|
tprot,"test protection",N/A,"privileged instruction"
|
|
tr,translate,implemented,
|
|
trace,trace,N/A,"privileged instruction"
|
|
trt,"translate and test","not implemented",
|
|
ts,"test and set","won't do","deprecated instruction"
|
|
tsch,"test subchannel",N/A,"privileged instruction"
|
|
unpk,unpack,"not implemented",
|
|
upt,"update tree","not implemented",
|
|
x,"exclusive OR",implemented,
|
|
xc,"exclusive OR",implemented,
|
|
xi,"exclusive OR",implemented,
|
|
xr,"exclusive OR",implemented,
|
|
zap,"zero and add","not implemented",
|
|
ahi,"add halfword immediate",implemented,
|
|
brxh,"branch relative on index high",implemented,
|
|
brxle,"branch relative on index low or equal",implemented,
|
|
bras,"branch relative and save",implemented,
|
|
brc,"branch relative on condition",implemented,
|
|
brct,"branch relative on count",implemented,
|
|
cksm,checksum,implemented,
|
|
chi,"compare halfword immediate",implemented,
|
|
clcle,"compare logical long extended",implemented,
|
|
lhi,"load halfword immediate",implemented,
|
|
mvcle,"move long extended",implemented,
|
|
mhi,"multiply halfword immediate",implemented,
|
|
msr,"multiply single",implemented,
|
|
ms,"multiply single",implemented,
|
|
tmlh,"test under mask low high",implemented,
|
|
tmll,"test under mask low low",implemented,
|
|
axbr,"add extended bfp",implemented,
|
|
adbr,"add long bfp",implemented,
|
|
adb,"add long bfp",implemented,
|
|
aebr,"add short bfp",implemented,
|
|
aeb,"add short bfp",implemented,
|
|
cxbr,"compare extended bfp",implemented,
|
|
cdbr,"compare long bfp",implemented,
|
|
cdb,"compare long bfp",implemented,
|
|
cebr,"compare short bfp",implemented,
|
|
ceb,"compare short bfp",implemented,
|
|
kxbr,"compare and signal extended bfp","not implemented",
|
|
kdbr,"compare and signal long bfp","not implemented",
|
|
kdb,"compare and signal long bfp","not implemented",
|
|
kebr,"compare and signal short bfp","not implemented",
|
|
keb,"compare and signal short bfp","not implemented",
|
|
cxfbr,"convert from fixed 32 to extended bfp",implemented,
|
|
cdfbr,"convert from fixed 32 to long bfp",implemented,
|
|
cefbr,"convert from fixed 32 to short bfp",implemented,
|
|
cfxbr,"convert to fixed extended bfp to 32",implemented,
|
|
cfdbr,"convert to fixed long bfp to 32",implemented,
|
|
cfebr,"convert to fixed short bfp to 32",implemented,
|
|
dxbr,"divide extended bfp",implemented,
|
|
ddbr,"divide long bfp",implemented,
|
|
ddb,"divide long bfp",implemented,
|
|
debr,"divide short bfp",implemented,
|
|
deb,"divide short bfp",implemented,
|
|
didbr,"divide to integer long bfp","not implemented",
|
|
diebr,"divide to integer short bfp","not implemented",
|
|
efpc,"extract fpc",implemented,
|
|
ltxbr,"load and test extended bfp",implemented,
|
|
ltdbr,"load and test long bfp",implemented,
|
|
ltebr,"load and test short bfp",implemented,
|
|
lcxbr,"load complement extended bfp",implemented,
|
|
lcdbr,"load complement long bfp",implemented,
|
|
lcebr,"load complement short bfp",implemented,
|
|
fixbr,"load fp integer extended bfp",implemented,
|
|
fidbr,"load fp integer long bfp",implemented,
|
|
fiebr,"load fp integer short bfp",implemented,
|
|
lfpc,"load fpc",implemented,
|
|
lxdbr,"load lengthened long to extended bfp",implemented,
|
|
lxdb,"load lengthened long to extended bfp",implemented,
|
|
lxebr,"load lengthened short to extended bfp",implemented,
|
|
lxeb,"load lengthened short to extended bfp",implemented,
|
|
ldebr,"load lengthened short to long bfp",implemented,
|
|
ldeb,"load lengthened short to long bfp",implemented,
|
|
lnxbr,"load negative extended bfp",implemented,
|
|
lndbr,"load negative long bfp",implemented,
|
|
lnebr,"load negative short bfp",implemented,
|
|
lpxbr,"load positive extended bfp",implemented,
|
|
lpdbr,"load positive long bfp",implemented,
|
|
lpebr,"load positive short bfp",implemented,
|
|
ldxbr,"load rounded extended to long bfp",implemented,
|
|
lexbr,"load rounded extended to short bfp",implemented,
|
|
ledbr,"load rounded long to short bfp",implemented,
|
|
mxbr,"multiply extended bfp",implemented,
|
|
mdbr,"multiply long bfp",implemented,
|
|
mdb,"multiply long bfp",implemented,
|
|
mxdbr,"multiply long to extended bfp","not implemented",
|
|
mxdb,"multiply long to extended bfp","not implemented",
|
|
meebr,"multiply short bfp",implemented,
|
|
meeb,"multiply short bfp",implemented,
|
|
mdebr,"multiply short to long bfp","not implemented",
|
|
mdeb,"multiply short to long bfp","not implemented",
|
|
madbr,"multiply and add long bfp",implemented,
|
|
madb,"multiply and add long bfp",implemented,
|
|
maebr,"multiply and add short bfp",implemented,
|
|
maeb,"multiply and add short bfp",implemented,
|
|
msdbr,"multiply and subtract long bfp",implemented,
|
|
msdb,"multiply and subtract long bfp",implemented,
|
|
msebr,"multiply and subtract short bfp",implemented,
|
|
mseb,"multiply and subtract short bfp",implemented,
|
|
sfpc,"set fpc",implemented,
|
|
srnm,"set rounding mode",implemented,
|
|
sqxbr,"square root extended bfp",implemented,
|
|
sqdbr,"square root long bfp",implemented,
|
|
sqdb,"square root long bfp",implemented,
|
|
sqebr,"square root short bfp",implemented,
|
|
sqeb,"square root short bfp",implemented,
|
|
stfpc,"store fpc",implemented,
|
|
sxbr,"subtract extended bfp",implemented,
|
|
sdbr,"subtract long bfp",implemented,
|
|
sdb,"subtract long bfp",implemented,
|
|
sebr,"subtract short bfp",implemented,
|
|
seb,"subtract short bfp",implemented,
|
|
tcxb,"test data class extended bfp",implemented,
|
|
tcdb,"test data class long bfp",implemented,
|
|
tceb,"test data class short bfp",implemented,
|
|
siga,"signal adapter","not implemented",
|
|
plo,"perform locked operation","not implemented",
|
|
bsa,"branch and set authority",N/A,"privileged instruction"
|
|
rp,"resume program",N/A,"privileged instruction"
|
|
sckpf,"set clock programmable field",N/A,"privileged instruction"
|
|
stsi,"store system information",N/A,"privileged instruction"
|
|
trap2,trap,"not implemented",
|
|
trap4,trap4,"not implemented",
|
|
stcke,"store clock extended",implemented,
|
|
tre,"translate extended",implemented,
|
|
mvclu,"move long unicode","not implemented",
|
|
pka,"pack ascii","not implemented",
|
|
pku,"pack unicode","not implemented",
|
|
troo,"translate one to one",implemented,
|
|
trot,"translate one to two",implemented,
|
|
trto,"translate two to one",implemented,
|
|
trtt,"translate two to two",implemented,
|
|
unpka,"unpack ascii","not implemented",
|
|
unpku,"unpack unicode","not implemented",
|
|
thder,"convert short bfp to long hfp","won't do","hfp instruction"
|
|
thdr,"convert long bfp to long hfp","won't do","hfp instruction"
|
|
tbedr,"convert long hfp to short bfp","won't do","hfp instruction"
|
|
tbdr,"convert long hfp to long bfp","won't do","hfp instruction"
|
|
lzer,"load short zero",implemented,
|
|
lzdr,"load long zero",implemented,
|
|
lzxr,"load extended zero",implemented,
|
|
bctgr,"branch on count 64",implemented,
|
|
lpgr,"load positive 64",implemented,
|
|
lpgfr,"load positive 64<32",implemented,
|
|
lngr,"load negative 64",implemented,
|
|
lngfr,"load negative 64<32",implemented,
|
|
ltgr,"load and test 64",implemented,
|
|
ltgfr,"load and test 64<32",implemented,
|
|
lcgr,"load complement 64",implemented,
|
|
lcgfr,"load complement 64<32",implemented,
|
|
ngr,"and 64",implemented,
|
|
clgr,"compare logical 64",implemented,
|
|
clgfr,"compare logical 64<32",implemented,
|
|
ogr,"or 64",implemented,
|
|
xgr,"exclusive or 64",implemented,
|
|
lgr,"load 64",implemented,
|
|
lgfr,"load 64<32",implemented,
|
|
cgr,"compare 64",implemented,
|
|
cgfr,"compare 64<32",implemented,
|
|
agr,"add 64",implemented,
|
|
agfr,"add 64<32",implemented,
|
|
sgr,"subtract 64",implemented,
|
|
sgfr,"subtract 64<32",implemented,
|
|
algr,"add logical 64",implemented,
|
|
algfr,"add logical 64<32",implemented,
|
|
slgr,"subtract logical 64",implemented,
|
|
slgfr,"subtract logical 64<32",implemented,
|
|
bctg,"branch on count 64",implemented,
|
|
cvdg,"convert to decimal 64","not implemented",
|
|
cvbg,"convert to binary 64","not implemented",
|
|
stg,"store 64",implemented,
|
|
ng,"and 64",implemented,
|
|
clg,"compare logical 64",implemented,
|
|
clgf,"compare logical 64<32",implemented,
|
|
og,"or 64",implemented,
|
|
xg,"exclusive or 64",implemented,
|
|
lg,"load 64",implemented,
|
|
lgf,"load 64<32",implemented,
|
|
lgh,"load halfword 64",implemented,
|
|
cg,"compare 64",implemented,
|
|
cgf,"compare 64<32",implemented,
|
|
ag,"add 64",implemented,
|
|
agf,"add 64<32",implemented,
|
|
sg,"subtract 64",implemented,
|
|
sgf,"subtract 64<32",implemented,
|
|
alg,"add logical 64",implemented,
|
|
algf,"add logical 64<32",implemented,
|
|
slg,"subtract logical 64",implemented,
|
|
slgf,"subtract logical 64<32",implemented,
|
|
msg,"multiply single 64",implemented,
|
|
msgf,"multiply single 64<32",implemented,
|
|
brxhg,"branch relative on index high 64",implemented,
|
|
brxlg,"branch relative on index low or equal 64",implemented,
|
|
bxhg,"branch on index high 64",implemented,
|
|
bxleg,"branch on index low or equal 64",implemented,
|
|
srlg,"shift right single logical 64",implemented,
|
|
sllg,"shift left single logical 64",implemented,
|
|
srag,"shift right single 64",implemented,
|
|
slag,"shift left single 64",implemented,
|
|
stmg,"store multiple 64",implemented,
|
|
stmh,"store multiple high",implemented,
|
|
lmg,"load multiple 64",implemented,
|
|
lmh,"load multiple high",implemented,
|
|
lmd,"load multiple disjoint","not implemented",
|
|
tracg,"trace 64",N/A,"privileged instruction"
|
|
lrag,"load real address 64",N/A,"privileged instruction"
|
|
strag,"store read address",N/A,"privileged instruction"
|
|
stctg,"store control 64",N/A,"privileged instruction"
|
|
lctlg,"load control 64",N/A,"privileged instruction"
|
|
csg,"compare and swap 64",implemented,
|
|
cdsg,"compare double and swap 64",implemented,
|
|
clmh,"compare logical characters under mask high",implemented,
|
|
stcmh,"store characters under mask high",implemented,
|
|
icmh,"insert characters under mask high",implemented,
|
|
tmhh,"test under mask high high",implemented,
|
|
tmhl,"test under mask high low",implemented,
|
|
brcl,"branch relative on condition long",implemented,
|
|
brasl,"branch relative and save long",implemented,
|
|
brctg,"branch relative on count 64",implemented,
|
|
lghi,"load halfword immediate 64",implemented,
|
|
aghi,"add halfword immediate 64",implemented,
|
|
mghi,"multiply halfword immediate 64",implemented,
|
|
cghi,"compare halfword immediate 64",implemented,
|
|
sturg,"store using real address 64",N/A,"privileged instruction"
|
|
eregg,"extract stacked registers 64","not implemented",
|
|
lurag,"load using real address 64",N/A,"privileged instruction"
|
|
msgr,"multiply single 64",implemented,
|
|
msgfr,"multiply single 64<32",implemented,
|
|
cegbr,"convert from fixed 64 to short bfp",implemented,
|
|
cdgbr,"convert from fixed 64 to long bfp",implemented,
|
|
cxgbr,"convert from fixed 64 to extended bfp",implemented,
|
|
cgebr,"convert to fixed short bfd to 64",implemented,
|
|
cgdbr,"convert to fixed long bfp to 64",implemented,
|
|
cgxbr,"convert to fixed extended bfp to 64",implemented,
|
|
cegr,"convert from fixed 64 to short hfp","won't do","hfp instruction"
|
|
cdgr,"convert from fixed 64 to long hfp","won't do","hfp instruction"
|
|
cxgr,"convert from fixed 64 to extended hfp","won't do","hfp instruction"
|
|
cger,"convert to fixed short hfp to 64","won't do","hfp instruction"
|
|
cgdr,"convert to fixed long hfp to 64","won't do","hfp instruction"
|
|
cgxr,"convert to fixed extended hfp to 64","won't do","hfp instruction"
|
|
tam,"test addressing mode","not implemented",
|
|
sam24,"set addressing mode 24","not implemented",
|
|
sam31,"set addressing mode 31","not implemented",
|
|
sam64,"set addressing mode 64","not implemented",
|
|
iihh,"insert immediate high high",implemented,
|
|
iihl,"insert immediate high low",implemented,
|
|
iilh,"insert immediate low high",implemented,
|
|
iill,"insert immediate low low",implemented,
|
|
nihh,"and immediate high high",implemented,
|
|
nihl,"and immediate high low",implemented,
|
|
nilh,"and immediate low high",implemented,
|
|
nill,"and immediate low low",implemented,
|
|
oihh,"or immediate high high",implemented,
|
|
oihl,"or immediate high low",implemented,
|
|
oilh,"or immediate low high",implemented,
|
|
oill,"or immediate low low",implemented,
|
|
llihh,"load logical immediate high high",implemented,
|
|
llihl,"load logical immediate high low",implemented,
|
|
llilh,"load logical immediate low high",implemented,
|
|
llill,"load logical immediate low low",implemented,
|
|
stfl,"store facility list",N/A,"privileged instruction"
|
|
lpswe,"load psw extended",N/A,"privileged instruction"
|
|
dsgr,"divide single 64",implemented,
|
|
lrvgr,"load reversed 64",implemented,
|
|
llgfr,"load logical 64<32",implemented,
|
|
llgtr,"load logical thirty one bits",implemented,
|
|
dsgfr,"divide single 64<32",implemented,
|
|
lrvr,"load reversed 32",implemented,
|
|
mlgr,"multiply logical 64",implemented,
|
|
dlgr,"divide logical 64",implemented,
|
|
alcgr,"add logical with carry 64",implemented,
|
|
slbgr,"subtract logical with borrow 64",implemented,
|
|
epsw,"extract psw","not implemented",
|
|
mlr,"multiply logical 32",implemented,
|
|
dlr,"divide logical 32",implemented,
|
|
alcr,"add logical with carry 32",implemented,
|
|
slbr,"subtract logical with borrow 32",implemented,
|
|
esea,"extract and set extended authority",N/A,"privileged instruction"
|
|
larl,"load address relative long",implemented,
|
|
dsg,"divide single 64",implemented,
|
|
lrvg,"load reversed 64",implemented,
|
|
llgf,"load logical 64<32",implemented,
|
|
llgt,"load logical thirty one bits",implemented,
|
|
dsgf,"divide single 64<32",implemented,
|
|
lrv,"load reversed 32",implemented,
|
|
lrvh,"load reversed 16",implemented,
|
|
strvg,"store reversed 64",implemented,
|
|
strv,"store reversed 32",implemented,
|
|
strvh,"store reversed 64",implemented,
|
|
mlg,"multiply logical 64",implemented,
|
|
dlg,"divide logical 64",implemented,
|
|
alcg,"add logical with carry 64",implemented,
|
|
slbg,"subtract logical with borrow 64",implemented,
|
|
stpq,"store pair to quadword",implemented,
|
|
lpq,"load pair from quadword",implemented,
|
|
ml,"multiply logical 32",implemented,
|
|
dl,"divide logical 32",implemented,
|
|
alc,"add logical with carry 32",implemented,
|
|
slb,"subtract logical with borrow 32",implemented,
|
|
llgc,"load logical character",implemented,
|
|
llgh,"load logical halfword",implemented,
|
|
rllg,"rotate left single logical 64",implemented,
|
|
rll,"rotate left single logical 32",implemented,
|
|
cxfr,"convert from fixed 32 to extended hfp","won't do","hfp instruction"
|
|
cdfr,"convert from fixed 32 to long hfp","won't do","hfp instruction"
|
|
cefr,"convert from fixed 32 to short hfp","won't do","hfp instruction"
|
|
cfxr,"convert to fixed extended hfp to 32","won't do","hfp instruction"
|
|
cfdr,"convert to fixed long hfp to 32","won't do","hfp instruction"
|
|
cfer,"convert to fixed short hfp to 32","won't do","hfp instruction"
|
|
ltxr,"load and test extended hfp","won't do","hfp instruction"
|
|
lcxr,"load complement extended hfp","won't do","hfp instruction"
|
|
fixr,"load fp integer extended hfp","won't do","hfp instruction"
|
|
fidr,"load fp integer long hfp","won't do","hfp instruction"
|
|
fier,"load fp integer short hfp","won't do","hfp instruction"
|
|
lxdr,"load lengthened long to extended hfp","won't do","hfp instruction"
|
|
lxd,"load lengthened long to extended hfp","won't do","hfp instruction"
|
|
lxer,"load lengthened short to extended hfp","won't do","hfp instruction"
|
|
lxe,"load lengthened short to extended hfp","won't do","hfp instruction"
|
|
lder,"load lengthened short to long hfp",implemented,"hfp instruction"
|
|
lde,"load lengthened short to long hfp",implemented,"hfp instruction"
|
|
lnxr,"load negative extended hfp","won't do","hfp instruction"
|
|
lpxr,"load positive extended hfp","won't do","hfp instruction"
|
|
lexr,"load rounded extended to short hfp","won't do","hfp instruction"
|
|
meer,"multiply short hfp","won't do","hfp instruction"
|
|
mee,"multiply short hfp","won't do","hfp instruction"
|
|
sqxr,"square root extended hfp","won't do","hfp instruction"
|
|
sqe,"square root short hfp","won't do","hfp instruction"
|
|
sqd,"square root long hfp","won't do","hfp instruction"
|
|
cmpsc,"compression call","not implemented",
|
|
tp,"test decimal","not implemented",
|
|
lxr,"load extended fp",implemented,
|
|
pgin,"page in",N/A,"privileged instruction"
|
|
pgout,"page out",N/A,"privileged instruction"
|
|
xsch,"cancel subchannel",N/A,"privileged instruction"
|
|
ay,"add with long offset",implemented,
|
|
ahy,"add halfword with long offset",implemented,
|
|
aly,"add logical with long offset",implemented,
|
|
niy,"and immediate with long offset",implemented,
|
|
ny,"and with long offset",implemented,
|
|
cy,"compare with long offset",implemented,
|
|
csy,"compare and swap with long offset",implemented,
|
|
cdsy,"compare double and swap with long offset",implemented,
|
|
chy,"compare halfword with long offset",implemented,
|
|
cly,"compare logical with long offset",implemented,
|
|
cliy,"compare logical immediate with long offset",implemented,
|
|
clmy,"compare logical characters under mask with long offset",implemented,
|
|
cvby,"convert to binary with long offset",implemented,
|
|
cvdy,"convert to decimal with long offset",implemented,
|
|
xiy,"exclusive or immediate with long offset",implemented,
|
|
xy,"exclusive or with long offset",implemented,
|
|
icy,"insert character with long offset",implemented,
|
|
icmy,"insert characters with long offset",implemented,
|
|
ldy,"load (long) with long offset",implemented,
|
|
ley,"load (short) with long offset",implemented,
|
|
ly,"load with long offset",implemented,
|
|
lamy,"load access multiple",implemented,
|
|
lay,"load address with long offset",implemented,
|
|
lb,"load byte with long offset",implemented,
|
|
lgb,"load byte with long offset 64",implemented,
|
|
lhy,"load halfword with long offset",implemented,
|
|
lmy,"load multiple with long offset",implemented,
|
|
lray,"load real address with long offset",N/A,"privileged instruction"
|
|
mviy,"move immediate with long offset",implemented,
|
|
msy,"multiply single with long offset",implemented,
|
|
oiy,"or immediate with long offset",implemented,
|
|
oy,"or with long offset",implemented,
|
|
stdy,"store (long) with long offset",implemented,
|
|
stey,"store (short) with long offset",implemented,
|
|
sty,"store with long offset",implemented,
|
|
stamy,"store access multiple with long offset",implemented,
|
|
stcy,"store character with long offset",implemented,
|
|
stcmy,"store characters under mask with long offset",implemented,
|
|
sthy,"store halfword with long offset",implemented,
|
|
stmy,"store multiple with long offset",implemented,
|
|
sy,"subtract with long offset",implemented,
|
|
shy,"subtract halfword with long offset",implemented,
|
|
sly,"subtract logical with long offset",implemented,
|
|
tmy,"test under mask with long offset",implemented,
|
|
clclu,"compare logical long unicode with long offset","not implemented",
|
|
cspg,"compare and swap and purge",N/A,"privileged instruction"
|
|
idte,"invalidate dat table entry",N/A,"privileged instruction"
|
|
madr,"multiply and add long hfp","won't do","hfp instruction"
|
|
mad,"multiply and add long hfp","won't do","hfp instruction"
|
|
maer,"multiply and add short hfp","won't do","hfp instruction"
|
|
mae,"multiply and add short hfp","won't do","hfp instruction"
|
|
msdr,"multiply and subtract long hfp","won't do","hfp instruction"
|
|
msd,"multiply and subtract long hfp","won't do","hfp instruction"
|
|
mser,"mutliply and subtract short hfp","won't do","hfp instruction"
|
|
mse,"multiply and subttract short hfp","won't do","hfp instruction"
|
|
km,"cipher message","not implemented",
|
|
kmc,"cipher message with chaining","not implemented",
|
|
kmf,"cipher message with CFB","not implemented",
|
|
kmo,"cipher message with OFB","not implemented",
|
|
kmctr,"cipher message with counter","not implemented",
|
|
pcc,"perform cryptographic computation","not implemented",
|
|
kimd,"compute intermediate message digest","not implemented",
|
|
klmd,"compute last message digest","not implemented",
|
|
kmac,"compute message authentication code","not implemented",
|
|
afi,"add immediate 32",implemented,
|
|
agfi,"add immediate 64<32",implemented,
|
|
alfi,"add logical immediate 32",implemented,
|
|
algfi,"add logical immediate 64<32",implemented,
|
|
nihf,"and immediate high",implemented,
|
|
nilf,"and immediate low",implemented,
|
|
cfi,"compare immediate 32",implemented,
|
|
cgfi,"compare immediate 64<32",implemented,
|
|
clfi,"compare logical immediate 32",implemented,
|
|
clgfi,"compare logical immediate 64<32",implemented,
|
|
xihf,"exclusive or immediate high",implemented,
|
|
xilf,"exclusive or immediate low",implemented,
|
|
iihf,"insert immediate high",implemented,
|
|
iilf,"insert immediate low",implemented,
|
|
flogr,"find leftmost one",implemented,
|
|
lt,"load and test 32",implemented,
|
|
ltg,"load and test 64",implemented,
|
|
lbr,"load byte 32",implemented,
|
|
lgbr,"load byte 64",implemented,
|
|
lhr,"load halfword 32",implemented,
|
|
lghr,"load halfword 64",implemented,
|
|
lgfi,"load immediate 64<32",implemented,
|
|
llc,"load logical character 32",implemented,
|
|
llcr,"load logical character 32",implemented,
|
|
llgcr,"load logical character 64",implemented,
|
|
llh,"load logical halfword 32",implemented,
|
|
llhr,"load logical halfword 32",implemented,
|
|
llghr,"load logical halfword 64",implemented,
|
|
llihf,"load logical immediate high",implemented,
|
|
llilf,"load logical immediate low",implemented,
|
|
oihf,"or immediate high",implemented,
|
|
oilf,"or immediate low",implemented,
|
|
slfi,"subtract logical immediate 32",implemented,
|
|
slgfi,"subtract logical immediate 64<32",implemented,
|
|
ptff,"perform timing facility function",N/A,"privileged instruction"
|
|
stfle,"store facility list extended",implemented,
|
|
stckf,"store clock fast",implemented,
|
|
mvcos,"move with optional specifications",N/A,"privileged instruction"
|
|
lptea,"load page-table-entry address",N/A,"privileged instruction"
|
|
cu24,"convert utf-16 to utf-32",implemented,
|
|
cu21,"convert utf-16 to utf-8",implemented,
|
|
cu42,"convert utf-32 to utf-16",implemented,
|
|
cu41,"convert utf-32 to utf-8",implemented,
|
|
cu12,"convert utf-8 to utf-16",implemented,
|
|
cu14,"convert utf-8 to utf-32",implemented,
|
|
srstu,"search string unicode","not implemented",
|
|
trtr,"tranlate and test reverse","not implemented",
|
|
myr,"multiply unnormalized long hfp","won't do","hfp instruction"
|
|
myhr,"multiply unnormalized long hfp high","won't do","hfp instruction"
|
|
mylr,"multiply unnormalized long hfp low","won't do","hfp instruction"
|
|
my,"multiply unnormalized long hfp","won't do","hfp instruction"
|
|
myh,"multiply unnormalized long hfp high","won't do","hfp instruction"
|
|
myl,"multiply unnormalized long hfp low","won't do","hfp instruction"
|
|
mayr,"multiply and add unnormalized long hfp","won't do","hfp instruction"
|
|
mayhr,"multiply and add unnormalized long hfp high","won't do","hfp instruction"
|
|
maylr,"multiply and add unnormalized long hfp low","won't do","hfp instruction"
|
|
may,"multiply and add unnormalized long hfp","won't do","hfp instruction"
|
|
mayh,"multiply and add unnormalized long hfp high","won't do","hfp instruction"
|
|
mayl,"multiply and add unnormalized long hfp low","won't do","hfp instruction"
|
|
lpdfr,"load positive no cc",implemented,
|
|
lndfr,"load negative no cc",implemented,
|
|
cpsdr,"copy sign",implemented,
|
|
lcdfr,"load complement no cc",implemented,
|
|
ldgr,"load fpr from gr",implemented,
|
|
lgdr,"load gr from fpr",implemented,
|
|
cdtr,"compare long dfp",implemented
|
|
cxtr,"compare extended dfp",implemented
|
|
kdtr,"compare and signal long dfp","not implemented",
|
|
kxtr,"compare and signal extended dfp","not implemented",
|
|
cedtr,"compare exponent long dfp",implemented
|
|
cextr,"compare exponent extended dfp",implemented
|
|
cxgtr,"convert from fixed extended dfp",implemented
|
|
cdstr,"convert from signed bcd long dfp","not implemented",
|
|
cxstr,"convert from signed bcd extended dfp","not implemented",
|
|
cdutr,"convert from unsigned bcd to long dfp","not implemented",
|
|
cxutr,"convert from unsigned bcd to extended dfp","not implemented",
|
|
cgdtr,"convert from long dfp to fixed",implemented
|
|
cgxtr,"convert from extended dfp to fixed",implemented
|
|
csdtr,"convert from long dfp to signed bcd","not implemented",
|
|
csxtr,"convert from extended dfp to signed bcd","not implemented",
|
|
cudtr,"convert from long dfp to unsigned bcd","not implemented",
|
|
cuxtr,"convert from extended dfp to unsigned bcd","not implemented",
|
|
eedtr,"extract biased exponent from long dfp",implemented
|
|
eextr,"extract biased exponent from extended dfp",implemented
|
|
esdtr,"extract significance from long dfp",implemented
|
|
esxtr,"extract significance from extended dfp",implemented
|
|
iedtr,"insert biased exponent long dfp",implemented
|
|
iextr,"insert biased exponent extended dfp",implemented
|
|
ltdtr,"load and test long dfp",implemented
|
|
ltxtr,"load and test extended dfp",implemented
|
|
fidtr,"load fp integer long dfp","not implemented",
|
|
fixtr,"load fp integer extended dfp","not implemented",
|
|
lfas,"load fpc and signal","not implemented",
|
|
ldetr,"load lengthened long dfp",implemented
|
|
lxdtr,"load lengthened extended dfp",implemented
|
|
ledtr,"load rounded long dfp",implemented
|
|
ldxtr,"load rounded extended dfp",implemented
|
|
qadtr,"Quantize long dfp",implemented
|
|
qaxtr,"Quantize extended dfp",implemented
|
|
rrdtr,"Reround long dfp",implemented
|
|
rrxtr,"Reround extended dfp",implemented
|
|
srnmt,"set rounding mode dfp",implemented
|
|
sfasr,"set fpc and signal","not implemented",
|
|
sldt,"shift coefficient left long dfp",implemented
|
|
slxt,"shift coefficient left extended dfp",implemented
|
|
srdt,"shift coefficient right long dfp",implemented
|
|
srxt,"shift coefficient right extended dfp",implemented
|
|
tdcet,"test data class short dfp",implemented
|
|
tdcdt,"test data class long dfp",implemented
|
|
tdcxt,"test data class extended dfp",implemented
|
|
tdget,"test data group short dfp",implemented
|
|
tdgdt,"test data group long dfp",implemented
|
|
tdgxt,"test data group extended dfp",implemented
|
|
pfpo,"perform floating point operation",implemented
|
|
ectg,"extract cpu time","not implemented",
|
|
csst,"compare and swap and store","not implemented",
|
|
asi,"add immediate (32<8)",implemented,
|
|
agsi,"add immediate (64<8)",implemented,
|
|
alsi,"add logical with signed immediate (32<8)",implemented,
|
|
algsi,"add logical with signed immediate (64<8)",implemented,
|
|
crl,"compare relative long (32)",implemented,
|
|
cgrl,"compare relative long (64)",implemented,
|
|
cgfrl,"compare relative long (64<32)",implemented,
|
|
crb,"compare and branch (32)",implemented,
|
|
cgrb,"compare and branch (64)",implemented,
|
|
crj,"compare and branch relative (32)",implemented,
|
|
cgrj,"compare and branch relative (64)",implemented,
|
|
cib,"compare immediate and branch (32<8)",implemented,
|
|
cgib,"compare immediate and branch (64<8)",implemented,
|
|
cij,"compare immediate and branch relative (32<8)",implemented,
|
|
cgij,"compare immediate and branch relative (64<8)",implemented,
|
|
crt,"compare and trap","not implemented","issued by gcc"
|
|
cgrt,"compare and trap 64","not implemented","issued by gcc"
|
|
cit,"compare immediate and trap (32<16)","not implemented","issued by gcc"
|
|
cgit,"compare immediate and trap (64<16)","not implemented","issued by gcc"
|
|
cgh,"compare halfword (64<16)",implemented,
|
|
chhsi,"compare halfword immediate (16<16)",implemented,
|
|
chsi,"compare halfword immediate (32<16)",implemented,
|
|
cghsi,"compare halfword immediate (64<16)",implemented,
|
|
chrl,"compare halfword relative long (32<8)",implemented,
|
|
cghrl,"compare halfword relative long (64<8)",implemented,
|
|
clhhsi,"compare logical immediate (16<16)",implemented,
|
|
clfhsi,"compare logical immediate (32<16)",implemented,
|
|
clghsi,"compare logical immediate (64<16)",implemented,
|
|
clrl,"compare logical relative long (32)",implemented,
|
|
clgrl,"compare logical relative long (64)",implemented,
|
|
clgfrl,"compare logical relative long (64<32)",implemented,
|
|
clhrl,"compare logical relative long (32<16)",implemented,
|
|
clghrl,"compare logical relative long (64<16)",implemented,
|
|
clrb,"compare logical and branch (32)",implemented,
|
|
clgrb,"compare logical and branch (64)",implemented,
|
|
clrj,"compare logical and branch relative (32)",implemented,
|
|
clgrj,"compare logical and branch relative (64)",implemented,
|
|
clib,"compare logical immediate and branch (32<8)",implemented,
|
|
clgib,"compare logical immediate and branch (64<8)",implemented,
|
|
clij,"compare logical immediate and branch relative (32<8)",implemented,
|
|
clgij,"compare logical immediate and branch relative (64<8)",implemented,
|
|
clrt,"compare logical and trap (32)","not implemented",
|
|
clgrt,"compare logical and trap (64)","not implemented",
|
|
clfit,"compare logical and trap (32<16)","not implemented",
|
|
clgit,"compare logical and trap (64<16)","not implemented",
|
|
ecag,"extract cache attribute",implemented,
|
|
lrl,"load relative long (32)",implemented,
|
|
lgrl,"load relative long (64)",implemented,
|
|
lgfrl,"load relative long (64<32)",implemented,
|
|
laey,"load address extended",implemented,
|
|
ltgf,"load and test (64<32)",implemented,
|
|
lhrl,"load halfword relative long (32<16)",implemented,
|
|
lghrl,"load halfword relative long (64<16)",implemented,
|
|
llgfrl,"load logical relative long (64<32)",implemented,
|
|
llhrl,"load logical halfword relative long (32<16)",implemented,
|
|
llghrl,"load logical halfword relative long (64<16)",implemented,
|
|
mvhhi,"move (16<16)",implemented,
|
|
mvhi,"move (32<16)",implemented,
|
|
mvghi,"move (64<16)",implemented,
|
|
mfy,multiply,implemented,
|
|
mhy,"multiply halfword",implemented,
|
|
msfi,"multiply single immediate (32)",implemented,
|
|
msgfi,"multiply single immediate (64)",implemented,
|
|
pfd,"prefetch data",implemented,
|
|
pfdrl,"prefetch data relative long",implemented,
|
|
rnsbg,"rotate then and selected bits",implemented,
|
|
rxsbg,"rotate then exclusive or selected bits",implemented,
|
|
rosbg,"rotate then or selected bits",implemented,
|
|
risbg,"rotate then insert selected bits",implemented,
|
|
strl,"store relative long (32)",implemented,
|
|
stgrl,"store relative long (64)",implemented,
|
|
sthrl,"store halfword relative long",implemented,
|
|
exrl,"execute relative long",implemented,
|
|
ptf,"perform topology function",N/A,"privileged instruction"
|
|
pfmf,"perform frame management function",N/A,"privileged instruction"
|
|
trte,"translate and test extended","not implemented",
|
|
trtre,"translate and test reverse extended","not implemented",
|
|
ecpga,"extract coprocessor-group address",N/A,"privileged instruction"
|
|
ecctr,"extract cpu counter",N/A,"privileged instruction"
|
|
epctr,"extract peripheral counter",N/A,"privileged instruction"
|
|
lcctl,"load cpu-counter-set controls",N/A,"privileged instruction"
|
|
lpctl,"load peripheral-counter-set controls",N/A,"privileged instruction"
|
|
lsctl,"load sampling controls",N/A,"privileged instruction"
|
|
qctri,"query counter information",N/A,"privileged instruction"
|
|
qsi,"query sampling information",N/A,"privileged instruction"
|
|
scctr,"set cpu counter",N/A,"privileged instruction"
|
|
spctr,"set peripheral counter",N/A,"privileged instruction"
|
|
lpp,"load program parameter",N/A,"privileged instruction"
|
|
pckmo,"perform cryptographic key management operation",N/A,"privileged instruction"
|
|
ahhhr,"add high high",implemented,
|
|
ahhlr,"add high low",implemented,
|
|
aih,"add immediate high",implemented,
|
|
alhhhr,"add logical high high",implemented,
|
|
alhhlr,"add logical high low",implemented,
|
|
alsih,"add logical with signed immediate high with cc",implemented,
|
|
alsihn,"add logical with signed immediate high no cc",implemented,
|
|
brcth,"branch relative on count high",implemented,
|
|
chhr,"compare high high",implemented,
|
|
chlr,"compare high low",implemented,
|
|
chf,"compare high",implemented,
|
|
cih,"compare immediate high",implemented,
|
|
clhhr,"compare logical high high",implemented,
|
|
clhlr,"compare logical high low",implemented,
|
|
clhf,"compare logical high",implemented,
|
|
clih,"compare logical immediate",implemented,
|
|
lbh,"load byte high",implemented,
|
|
lhh,"load halfword high",implemented,
|
|
lfh,"load high",implemented,
|
|
llch,"load logical character high",implemented,
|
|
llhh,"load logical halfword high",implemented,
|
|
risbhg,"rotate then insert selected bits high",implemented,
|
|
risblg,"rotate then insert selected bits low",implemented,
|
|
stch,"store character high",implemented,
|
|
sthh,"store halfword high",implemented,
|
|
stfh,"store high",implemented,
|
|
shhhr,"subtract high high",implemented,
|
|
shhlr,"subtract high low",implemented,
|
|
slhhhr,"subtract logical high high",implemented,
|
|
slhhlr,"subtract logical high low",implemented,
|
|
laa,"load and add 32 bit",implemented,
|
|
laag,"load and add 64 bit",implemented,
|
|
laal,"load and add logical 32 bit",implemented,
|
|
laalg,"load and add logical 64 bit",implemented,
|
|
lan,"load and and 32 bit",implemented,
|
|
lang,"load and and 64 bit",implemented,
|
|
lax,"load and exclusive or 32 bit",implemented,
|
|
laxg,"load and exclusive or 64 bit",implemented,
|
|
lao,"load and or 32 bit",implemented,
|
|
laog,"load and or 64 bit",implemented,
|
|
lpd,"load pair disjoint 32 bit","not implemented",
|
|
lpdg,"load pair disjoint 64 bit","not implemented",
|
|
locr,"load on condition 32 bit",implemented,
|
|
locgr,"load on condition 64 bit",implemented,
|
|
loc,"load on condition 32 bit",implemented,
|
|
locg,"load on condition 64 bit",implemented,
|
|
stoc,"store on condition 32 bit",implemented,
|
|
stocg,"store on condition 64 bit",implemented,
|
|
ark,"add 3 operands 32 bit",implemented,
|
|
agrk,"add 3 operands 64 bit",implemented,
|
|
ahik,"add immediate 3 operands 32 bit",implemented,
|
|
aghik,"add immediate 3 operands 64 bit",implemented,
|
|
alrk,"add logical 3 operands 32 bit",implemented,
|
|
algrk,"add logical 3 operands 64 bit",implemented,
|
|
alhsik,"add logical immediate 3 operands 32 bit",implemented,
|
|
alghsik,"add logical immediate 3 operands 64 bit",implemented,
|
|
nrk,"and 3 operands 32 bit",implemented,
|
|
ngrk,"and 3 operands 64 bit",implemented,
|
|
xrk,"xor 3 operands 32 bit",implemented,
|
|
xgrk,"xor 3 operands 64 bit",implemented,
|
|
ork,"or 3 operands 32 bit",implemented,
|
|
ogrk,"or 3 operands 64 bit",implemented,
|
|
slak,"shift left single 3 operands 32 bit",implemented,
|
|
sllk,"shift left single logical 3 operands 32 bit",implemented,
|
|
srak,"shift right single 3 operands 32 bit",implemented,
|
|
srlk,"shift right single logical 3 operands 32 bit",implemented,
|
|
srk,"subtract 3 operands 32 bit",implemented,
|
|
sgrk,"subtract 3 operands 64 bit",implemented,
|
|
slrk,"subtract logical 3 operands 32 bit",implemented,
|
|
slgrk,"subtract logical 3 operands 64 bit",implemented,
|
|
popcnt,"population count","implemented",
|
|
rrbm,"reset reference bits multiple",N/A,"privileged instruction"
|
|
cefbra,"convert from 32 bit fixed to short bfp with rounding mode",implemented,
|
|
cdfbra,"convert from 32 bit fixed to long bfp with rounding mode",implemented,
|
|
cxfbra,"convert from 32 bit fixed to extended bfp with rounding mode",implemented,
|
|
cegbra,"convert from 64 bit fixed to short bfp with rounding mode",implemented,
|
|
cdgbra,"convert from 64 bit fixed to long bfp with rounding mode",implemented,
|
|
cxgbra,"convert from 64 bit fixed to extended bfp with rounding mode",implemented,
|
|
celfbr,"convert from 32 bit logical fixed to short bfp with rounding mode",implemented,
|
|
cdlfbr,"convert from 32 bit logical fixed to long bfp with rounding mode",implemented,
|
|
cxlfbr,"convert from 32 bit logical fixed to extended bfp with rounding mode",implemented,
|
|
celgbr,"convert from 64 bit logical fixed to short bfp with rounding mode",implemented,
|
|
cdlgbr,"convert from 64 bit logical fixed to long bfp with rounding mode",implemented,
|
|
cxlgbr,"convert from 64 bit logical fixed to extended bfp with rounding mode",implemented,
|
|
cfebra,"convert to 32 bit fixed from short bfp with rounding mode",implemented,
|
|
cfdbra,"convert to 32 bit fixed from long bfp with rounding mode",implemented,
|
|
cfxbra,"convert to 32 bit fixed from extended bfp with rounding mode",implemented,
|
|
cgebra,"convert to 64 bit fixed from short bfp with rounding mode",implemented,
|
|
cgdbra,"convert to 64 bit fixed from long bfp with rounding mode",implemented,
|
|
cgxbra,"convert to 64 bit fixed from extended bfp with rounding mode",implemented,
|
|
clfebr,"convert to 32 bit fixed logical from short bfp with rounding mode",implemented,
|
|
clfdbr,"convert to 32 bit fixed logical from long bfp with rounding mode",implemented,
|
|
clfxbr,"convert to 32 bit fixed logical from extended bfp with rounding mode",implemented,
|
|
clgebr,"convert to 64 bit fixed logical from short bfp with rounding mode",implemented,
|
|
clgdbr,"convert to 64 bit fixed logical from long bfp with rounding mode",implemented,
|
|
clgxbr,"convert to 64 bit fixed logical from extended bfp with rounding mode",implemented,
|
|
fiebra,"load fp integer short bfp with inexact suppression",implemented,"new to z196"
|
|
fidbra,"load fp integer long bfp with inexact suppression",implemented,"new to z196"
|
|
fixbra,"load fp integer extended bfp with inexact suppression",implemented,"new to z196"
|
|
ledbra,"load rounded short/long bfp to short/long bfp with rounding mode",implemented,
|
|
ldxbra,"load rounded long/extended bfp to long/extended bfp with rounding mode",implemented,
|
|
lexbra,"load rounded short/extended bfp to short/extended bfp with rounding mode",implemented,
|
|
adtra,"add long dfp with rounding mode",implemented
|
|
axtra,"add extended dfp with rounding mode",implemented
|
|
cdgtra,"convert from fixed long dfp with rounding mode",implemented
|
|
cdftr,"convert from 32 bit fixed to long dfp with rounding mode",implemented
|
|
cxftr,"convert from 32 bit fixed to extended dfp with rounding mode",implemented
|
|
cdlgtr,"convert from 64 bit fixed logical to long dfp with rounding mode",implemented
|
|
cxlgtr,"convert from 64 bit fixed logical to extended dfp with rounding mode",implemented
|
|
cdlftr,"convert from 32 bit fixed logical to long dfp with rounding mode",implemented
|
|
cxlftr,"convert from 32 bit fixed logical to extended dfp with rounding mode",implemented
|
|
cfdtr,"convert to 32 bit fixed from long dfp source with rounding mode",implemented
|
|
cfxtr,"convert to 32 bit fixed from extended dfp source with rounding mode",implemented
|
|
clgdtr,"convert to 64 bit fixed logical from long dfp with rounding mode",implemented
|
|
clgxtr,"convert to 64 bit fixed logical from extended dfp with rounding mode",implemented
|
|
clfdtr,"convert to 32 bit fixed logical from long dfp with rounding mode",implemented
|
|
clfxtr,"convert to 32 bit fixed logical from extended dfp with rounding mode",implemented
|
|
ddtra,"divide long dfp with rounding mode",implemented
|
|
dxtra,"divide extended dfp with rounding mode",implemented
|
|
mdtra,"multiply long dfp with rounding mode",implemented
|
|
mxtra,"multiply extended dfp with rounding mode",implemented
|
|
sdtra,"subtract long dfp with rounding mode",implemented
|
|
sxtra,"subtract extended dfp with rounding mode",implemented
|
|
srnmb,"set 3 bit bfp rounding mode",implemented,
|
|
etnd,"extract transaction nesting depth","not implemented",zEC12,
|
|
ntstg,"nontransactional store","not implemented",zEC12,
|
|
tabort,"transaction abort","not implemented",zEC12,
|
|
tbegin,"transaction begin","not implemented",zEC12,
|
|
tbeginc,"constrained transaction begin","not implemented",zEC12,
|
|
tend,"transaction end","not implemented",zEC12,
|
|
bpp,"branch prediction preload","not implemented",zEC12,
|
|
bprp,"branch prediction relative preload","not implemented",zEC12,
|
|
ppa,"perform processor assist","not implemented",zEC12,
|
|
niai,"next instruction access intent","not implemented",zEC12,
|
|
crdte,"compare and replace DAT table entry",N/A,"privileged instruction"
|
|
lat,"load and trap 32 bit","not implemented",zEC12,
|
|
lgat,"load and trap 64 bit","not implemented",zEC12,
|
|
lfhat,"load high and trap","not implemented",zEC12,
|
|
llgfat,"load logical and trap 32>64","not implemented",zEC12,
|
|
llgtat,"load logical thirty one bits and trap 31>64","not implemented",zEC12,
|
|
clt,"compare logical and trap 32 bit reg-mem","not implemented",zEC12,
|
|
clgt,"compare logical and trap 64 bit reg-mem","not implemented",zEC12,
|
|
risbgn,"rotate then insert selected bits nocc",implemented,zEC12,
|
|
cdzt,"convert from zoned long","not implemented",zEC12,
|
|
cxzt,"convert from zoned extended","not implemented",zEC12,
|
|
czdt,"convert to zoned long","not implemented",zEC12,
|
|
czxt,"convert to zoned extended","not implemented",zEC12,
|
|
vfsdb,"vector fp subtract long","not implemented",z13
|
|
vlpf,"vector load positive word","not implemented",z13
|
|
verllh,"vector element rotate left logical mem halfword","not implemented",z13
|
|
vzero,"vector set to zero","not implemented",z13
|
|
vmalof,"vector multiply and add logical odd word","not implemented",z13
|
|
vleif,"vector load word element immediate",implemented,z13
|
|
vlpb,"vector load positive byte","not implemented",z13
|
|
vmxlh,"vector maximum logical halfword","not implemented",z13
|
|
vpksfs,"vector pack saturate word","not implemented",z13
|
|
vfenezh,"vector find element not equal halfword","not implemented",z13
|
|
vecl,"vector element compare logical","not implemented",z13
|
|
verimb,"vector element rotate and insert under mask byte","not implemented",z13
|
|
vaccq,"vector add compute carry quadword","not implemented",z13
|
|
vleh,"vector load halfword element","implemented",z13
|
|
vst,"vector store","implemented",z13
|
|
vsteg,"vector store double word element","implemented",z13
|
|
vmnf,"vector minimum word","not implemented",z13
|
|
vavgl,"vector average logical","not implemented",z13
|
|
vfpsodb,"vector fp perform sign operation","not implemented",z13
|
|
llzrgf,"load logical and zero rightmost bytes 32->64","not implemented",z13
|
|
vledb,"vector fp load rounded","not implemented",z13
|
|
vldeb,"vector fp load lengthened","not implemented",z13
|
|
vclzg,"vector count leading zeros doubleword","not implemented",z13
|
|
vecg,"vector element compare double word","not implemented",z13
|
|
vpksgs,"vector pack saturate double word","not implemented",z13
|
|
vsel,"vector select","implemented",z13
|
|
vllezb,"vector load logical byte element and zero","implemented",z13
|
|
vfaezh,"vector find any element equal","not implemented",z13
|
|
vftci,"vector fp test data class immediate","not implemented",z13
|
|
veclb,"vector element compare logical byte","not implemented",z13
|
|
vuplhw,"vector unpack low halfword","not implemented",z13
|
|
veslvb,"vector element shift left reg byte","not implemented",z13
|
|
vuplh,"vector unpack logical high","implemented",z13
|
|
vlde,"vector fp load lengthened","not implemented",z13
|
|
vmoh,"vector multiply odd halfword","not implemented",z13
|
|
vfaehs,"vector find any element equal","not implemented",z13
|
|
vftcidb,"vector fp test data class immediate","not implemented",z13
|
|
vaq,"vector add quad word","not implemented",z13
|
|
vlgvh,"vector load gr from vr halfword element","implemented",z13
|
|
vchlg,"vector compare high logical double word","not implemented",z13
|
|
vlvgp,"vector load VR from GRs disjoint","implemented",z13
|
|
vceqg,"vector compare equal double word","not implemented",z13
|
|
vfeezh,"vector find element equal halfword","not implemented",z13
|
|
vlvgf,"vector load VR word element from GR","implemented",z13
|
|
vsteb,"vector store byte element","implemented",z13
|
|
vgmb,"vector generate mask byte","implemented",z13
|
|
vpklsf,"vector pack logical saturate word","implemented",z13
|
|
vmao,"vector multiply and add odd","not implemented",z13
|
|
vchf,"vector compare high word","not implemented",z13
|
|
vesraf,"vector element shift right arithmetic mem word","not implemented",z13
|
|
vsbiq,"vector subtract with borrow indication quadword","not implemented",z13
|
|
vuphb,"vector unpack high byte","implemented",z13
|
|
vgfmb,"vector galois field multiply sum byte","not implemented",z13
|
|
vrepih,"vector replicate immediate halfword","implemented",z13
|
|
vcdlg,"vector fp convert from logical 64 bit","not implemented",z13
|
|
cxpt,"convert from packed to extended dfp","not implemented",z13
|
|
vceqb,"vector compare equal byte","not implemented",z13
|
|
vstrczfs,"vector string range compare word","not implemented",z13
|
|
vpklshs,"vector pack logical saturate halfword","not implemented",z13
|
|
vlvgb,"vector load VR byte element from GR","implemented",z13
|
|
lcbb,"load count to block boundary","not implemented",z13
|
|
vlcf,"vector load complement word","not implemented",z13
|
|
vlvg,"vector load VR element from GR","implemented",z13
|
|
vmalef,"vector multiply and add logical even word","not implemented",z13
|
|
vn,"vector and","implemented",z13
|
|
vmae,"vector multiply and add even","not implemented",z13
|
|
vstrc,"vector string range compare","not implemented",z13
|
|
vfcedb,"vector fp compare equal","not implemented",z13
|
|
vgfm,"vector galois field multiply sum","not implemented",z13
|
|
vlrepb,"vector load and replicate byte elements","implemented",z13
|
|
vgfmag,"vector galois field multiply sum and accumulate doubleword","not implemented",z13
|
|
vflndb,"vector fp perform sign operation","not implemented",z13
|
|
vmaeb,"vector multiply and add even byte","not implemented",z13
|
|
vpkg,"vector pack double word","not implemented",z13
|
|
vsb,"vector subtract byte","not implemented",z13
|
|
vchl,"vector compare high logical","not implemented",z13
|
|
vlvgh,"vector load VR halfword element from GR","implemented",z13
|
|
locghi,"load halfword immediate on condition into 64 bit gpr","not implemented",z13
|
|
vmalb,"vector multiply and add low byte","not implemented",z13
|
|
vchlgs,"vector compare high logical double word","not implemented",z13
|
|
vstef,"vector store word element","implemented",z13
|
|
lzrf,"load and zero rightmost byte 32->32","not implemented",z13
|
|
vmrlh,"vector merge low halfword","implemented",z13
|
|
vchbs,"vector compare high byte","not implemented",z13
|
|
vesrlf,"vector element shift right logical mem word","not implemented",z13
|
|
vmxf,"vector maximum word","not implemented",z13
|
|
vgmh,"vector generate mask halfword","implemented",z13
|
|
vfenezb,"vector find element not equal byte","not implemented",z13
|
|
vpklsgs,"vector pack logical saturate double word","not implemented",z13
|
|
vpksg,"vector pack saturate double word","implemented",z13
|
|
vfaeh,"vector find any element equal halfword","not implemented",z13
|
|
vmlof,"vector multiply logical odd word","not implemented",z13
|
|
vmahh,"vector multiply and add high halfword","not implemented",z13
|
|
vx,"vector exclusive or","implemented",z13
|
|
vchlfs,"vector compare high logical word","not implemented",z13
|
|
vacccq,"vector add with carry compute carry quadword","not implemented",z13
|
|
vchb,"vector compare high byte","not implemented",z13
|
|
vmaloh,"vector multiply and add logical odd halfword","not implemented",z13
|
|
vmleh,"vector multiply logical even halfword","not implemented",z13
|
|
verimh,"vector element rotate and insert under mask halfword","not implemented",z13
|
|
vlrepf,"vector load and replicate word elements","implemented",z13
|
|
vgfmg,"vector galois field multiply sum doubleword","not implemented",z13
|
|
vpklsg,"vector pack logical saturate double word","implemented",z13
|
|
vesrlvf,"vector element shift right logical reg word","not implemented",z13
|
|
vrepg,"vector replicate double word","implemented",z13
|
|
vmalob,"vector multiply and add logical odd byte","not implemented",z13
|
|
vmxb,"vector maximum byte","not implemented",z13
|
|
vmnl,"vector minimum logical","not implemented",z13
|
|
vmng,"vector minimum doubleword","not implemented",z13
|
|
vchlb,"vector compare high logical byte","not implemented",z13
|
|
wfadb,"vector fp add","not implemented",z13
|
|
vmrl,"vector merge low","implemented",z13
|
|
wfk,"vector fp compare and signal scalar","not implemented",z13
|
|
vno,"vector nor","implemented",z13
|
|
vstrcf,"vector string range compare word","not implemented",z13
|
|
vfmsdb,"vector fp multiply and subtract","not implemented",z13
|
|
vavgh,"vector average half word","not implemented",z13
|
|
vchlhs,"vector compare high logical half word","not implemented",z13
|
|
vah,"vector add halfword","not implemented",z13
|
|
vmalhh,"vector multiply and add logical high halfword","not implemented",z13
|
|
wldeb,"vector fp load lengthened","not implemented",z13
|
|
vmrh,"vector merge high","implemented",z13
|
|
vclgdb,"vector fp convert to logical 64 bit","not implemented",z13
|
|
wfsqdb,"vector fp square root","not implemented",z13
|
|
vpopct,"vector population count","not implemented",z13
|
|
vfenef,"vector find element not equal word","not implemented",z13
|
|
vgfmf,"vector galois field multiply sum word","not implemented",z13
|
|
vgmf,"vector generate mask word","implemented",z13
|
|
vleg,"vector load double word element","implemented",z13
|
|
vmn,"vector minimum","not implemented",z13
|
|
vrepi,"vector replicate immediate","implemented",z13
|
|
vsegb,"vector sign extend byte to double word","implemented",z13
|
|
cpxt,"convert from extended dfp to packed","not implemented",z13
|
|
wftcidb,"vector fp test data class immediate","not implemented",z13
|
|
wfchedbs,"vector fp compare high or equal","not implemented",z13
|
|
vpks,"vector pack saturate","implemented",z13
|
|
veslg,"vector element shift left mem doubleword","not implemented",z13
|
|
vupllb,"vector unpack logical low byte","implemented",z13
|
|
vscbig,"vector subtract compute borrow indication doubleword","not implemented",z13
|
|
vsegh,"vector sign extend halfword to double word","implemented",z13
|
|
vsumb,"vector sum across word - byte elements","not implemented",z13
|
|
vgeg,"vector gather element 8 byte elements","implemented",z13
|
|
vcgd,"vector fp convert to fixed 64 bit","not implemented",z13
|
|
vuplhb,"vector unpack logical high byte","implemented",z13
|
|
verllv,"vector element rotate left logical reg","not implemented",z13
|
|
vavgb,"vector average byte","not implemented",z13
|
|
veclh,"vector element compare logical half word","not implemented",z13
|
|
vfmadb,"vector fp multiply and add","not implemented",z13
|
|
vesravb,"vector element shift right arithmetic reg byte","not implemented",z13
|
|
vmaleb,"vector multiply and add logical even byte","not implemented",z13
|
|
vuplf,"vector unpack low word","not implemented",z13
|
|
vsbi,"vector subtract with borrow indication","not implemented",z13
|
|
vupll,"vector unpack logical low","implemented",z13
|
|
vmrhh,"vector merge high halfword","not implemented",z13
|
|
vfenezbs,"vector find element not equal byte","not implemented",z13
|
|
vmhb,"vector multiply high byte","not implemented",z13
|
|
vfmdb,"vector fp multiply","not implemented",z13
|
|
vesrlg,"vector element shift right logical mem doubleword","not implemented",z13
|
|
vmahb,"vector multiply and add high byte","not implemented",z13
|
|
vstrczf,"vector string range compare word","not implemented",z13
|
|
wfcedb,"vector fp compare equal","not implemented",z13
|
|
vscbih,"vector subtract compute borrow indication halfword","not implemented",z13
|
|
vlch,"vector load complement halfword","not implemented",z13
|
|
vfenebs,"vector find element not equal byte","not implemented",z13
|
|
vpklsh,"vector pack logical saturate halfword","implemented",z13
|
|
vlgv,"vector load gr from vr element","implemented",z13
|
|
vchfs,"vector compare high word","not implemented",z13
|
|
vctzb,"vector count trailing zeros byte","not implemented",z13
|
|
vfaef,"vector find any element equal word","not implemented",z13
|
|
vstrch,"vector string range compare halfword","not implemented",z13
|
|
wfidb,"vector load fp integer","not implemented",z13
|
|
vmrhb,"vector merge high byte","not implemented",z13
|
|
vuph,"vector unpack high","implemented",z13
|
|
vperm,"vector permute","implemented",z13
|
|
vrep,"vector replicate","implemented",z13
|
|
vmalhb,"vector multiply and add logical high byte","not implemented",z13
|
|
vleib,"vector load byte element immediate","implemented",z13
|
|
vavg,"vector average","not implemented",z13
|
|
vfenefs,"vector find element not equal word","not implemented",z13
|
|
vsumh,"vector sum across word - halfword elements","not implemented",z13
|
|
vchh,"vector compare high half word","not implemented",z13
|
|
wcdgb,"vector fp convert from fixed 64 bit","not implemented",z13
|
|
verllvb,"vector element rotate left logical reg byte","not implemented",z13
|
|
vec,"vector element compare","not implemented",z13
|
|
vpdi,"vector permute double word immediate",implemented,z13
|
|
vfchedb,"vector fp compare high or equal long","not implemented",z13
|
|
vchlh,"vector compare high logical half word","not implemented",z13
|
|
vmaleh,"vector multiply and add logical even halfword","not implemented",z13
|
|
vstrcb,"vector string range compare byte","not implemented",z13
|
|
vsumqg,"vector sum across quadword - doubleword elements","not implemented",z13
|
|
vlc,"vector load complement","not implemented",z13
|
|
vlreph,"vector load and replicate halfword elements",implemented,z13
|
|
vistrb,"vector isolate string byte","not implemented",z13
|
|
vmo,"vector multiply odd","not implemented",z13
|
|
vmxg,"vector maximum doubleword","not implemented",z13
|
|
vsrab,"vector shift right arithmetic by byte","not implemented",z13
|
|
vsbcbiq,"vector subtract with borrow compute borrow indication quadword","not implemented",z13
|
|
wfchdb,"vector fp compare high long","not implemented",z13
|
|
vmlhf,"vector multiply logical high word","not implemented",z13
|
|
vesra,"vector element shift right arithmetic mem","not implemented",z13
|
|
vmnh,"vector minimum halfword","not implemented",z13
|
|
vled,"vector fp load rounded","not implemented",z13
|
|
vstrczbs,"vector string range compare byte","not implemented",z13
|
|
vaccb,"vector add compute carry byte","not implemented",z13
|
|
vmahf,"vector multiply and add high word","not implemented",z13
|
|
wfcedbs,"vector fp compare equal long","not implemented",z13
|
|
vmeh,"vector multiply even halfword","not implemented",z13
|
|
vclzb,"vector count leading zeros byte","not implemented",z13
|
|
vmh,"vector multiply high","not implemented",z13
|
|
vllez,"vector load logical element and zero",implemented,z13
|
|
vnc,"vector and with complement","not implemented",z13
|
|
vesrlvg,"vector element shift right logical reg doubleword","not implemented",z13
|
|
vrepif,"vector replicate immediate word",implemented,z13
|
|
vfd,"vector fp divide","not implemented",z13
|
|
vesrlb,"vector element shift right logical mem byte","not implemented",z13
|
|
vavglg,"vector average logical double word","not implemented",z13
|
|
vpksh,"vector pack saturate halfword",implemented,z13
|
|
veslv,"vector element shift left reg","not implemented",z13
|
|
vone,"vector set to ones","not implemented",z13
|
|
vsrl,"vector shift right logical","not implemented",z13
|
|
vcdg,"vector fp convert from fixed 64 bit","not implemented",z13
|
|
vmlhw,"vector multiply low halfword","not implemented",z13
|
|
vscbib,"vector subtract compute borrow indication byte","not implemented",z13
|
|
vrepib,"vector replicate immediate byte",implemented,z13
|
|
vpk,"vector pack",implemented,z13
|
|
vmhh,"vector multiply high halfword","not implemented",z13
|
|
vfaezhs,"vector find any element equal","not implemented",z13
|
|
vaf,"vector add word","not implemented",z13
|
|
vmalh,"vector multiply and add logical high","not implemented",z13
|
|
vgmg,"vector generate mask double word",implemented,z13
|
|
vstrczh,"vector string range compare halfword","not implemented",z13
|
|
vag,"vector add double word","not implemented",z13
|
|
vllezf,"vector load logical word element and zero",implemented,z13
|
|
vistrbs,"vector isolate string byte","not implemented",z13
|
|
vstm,"vector store multiple",implemented,z13
|
|
vgfmh,"vector galois field multiply sum halfword","not implemented",z13
|
|
verllvf,"vector element rotate left logical reg word","not implemented",z13
|
|
vsra,"vector shift right arithmetic","not implemented",z13
|
|
vslb,"vector shift left by byte","not implemented",z13
|
|
vesravf,"vector element shift right arithmetic reg word","not implemented",z13
|
|
vfcedbs,"vector fp compare equal long","not implemented",z13
|
|
vceqbs,"vector compare equal byte","not implemented",z13
|
|
vsbcbi,"vector subtract with borrow compute borrow indication","not implemented",z13
|
|
vmle,"vector multiply logical even","not implemented",z13
|
|
vfaezfs,"vector find any element equal","not implemented",z13
|
|
vsumg,"vector sum across doubleword","not implemented",z13
|
|
vfaeb,"vector find any element equal byte","not implemented",z13
|
|
vleih,"vector load halfword element immediate",implemented,z13
|
|
vmlob,"vector multiply logical odd byte","not implemented",z13
|
|
vllezh,"vector load logical halfword element and zero",implemented,z13
|
|
vmalo,"vector multiply and add logical odd","not implemented",z13
|
|
vclzh,"vector count leading zeros halfword","not implemented",z13
|
|
vesravh,"vector element shift right arithmetic reg halfword","not implemented",z13
|
|
vceqfs,"vector compare equal word","not implemented",z13
|
|
vlp,"vector load positive","not implemented",z13
|
|
wfmsdb,"vector fp multiply and subtract long","not implemented",z13
|
|
vstrcbs,"vector string range compare byte","not implemented",z13
|
|
vaccg,"vector add compute carry doubleword","not implemented",z13
|
|
wfsdb,"vector fp subtract long","not implemented",z13
|
|
vfee,"vector find element equal","not implemented",z13
|
|
vmxh,"vector maximum halfword","not implemented",z13
|
|
vtm,"vector test under mask","not implemented",z13
|
|
vctzf,"vector count trailing zeros word","not implemented",z13
|
|
vfms,"vector fp multiply and subtract","not implemented",z13
|
|
vavgg,"vector average double word","not implemented",z13
|
|
vistr,"vector isolate string","not implemented",z13
|
|
vesrlvb,"vector element shift right logical reg byte","not implemented",z13
|
|
vesrl,"vector element shift right logical mem","not implemented",z13
|
|
vmah,"vector multiply and add high","not implemented",z13
|
|
vesrlvh,"vector element shift right logical reg halfword","not implemented",z13
|
|
vesrah,"vector element shift right arithmetic mem halfword","not implemented",z13
|
|
vrepig,"vector replicate immediate double word",implemented,z13
|
|
wfddb,"vector fp divide long","not implemented",z13
|
|
vmhf,"vector multiply high word","not implemented",z13
|
|
vupllf,"vector unpack logical low word",implemented,z13
|
|
veslf,"vector element shift left mem word","not implemented",z13
|
|
wflpdb,"vector fp perform sign operation long","not implemented",z13
|
|
vscbi,"vector subtract compute borrow indication","not implemented",z13
|
|
vmnlb,"vector minimum logical byte","not implemented",z13
|
|
veslh,"vector element shift left mem halfword","not implemented",z13
|
|
vfaebs,"vector find any element equal","not implemented",z13
|
|
vleb,"vector load byte element",implemented,z13
|
|
vfaezb,"vector find any element equal","not implemented",z13
|
|
vlbb,"vector load to block boundary",implemented,z13
|
|
vflcdb,"vector fp perform sign operation long","not implemented",z13
|
|
vmlo,"vector multiply logical odd","not implemented",z13
|
|
vlgvf,"vector load gr from vr word element",implemented,z13
|
|
vavgf,"vector average word","not implemented",z13
|
|
veslvh,"vector element shift left reg halfword","not implemented",z13
|
|
vacch,"vector add compute carry halfword","not implemented",z13
|
|
vsumgh,"vector sum across doubleword - halfword","not implemented",z13
|
|
vmaeh,"vector multiply and add even halfword","not implemented",z13
|
|
vmnlh,"vector minimum logical halfword","not implemented",z13
|
|
vstl,"vector store with length",implemented,z13
|
|
wfmadb,"vector fp multiply and add long","not implemented",z13
|
|
vme,"vector multiply even","not implemented",z13
|
|
wfmdb,"vector fp multiply long","not implemented",z13
|
|
wflcdb,"vector fp perform sign operation long","not implemented",z13
|
|
vreph,"vector replicate halfword",implemented,z13
|
|
vclgd,"vector fp convert to logical 64 bit","not implemented",z13
|
|
vpkls,"vector pack logical saturate",implemented,z13
|
|
vsf,"vector subtract word","not implemented",z13
|
|
vflpdb,"vector fp perform sign operation long","not implemented",z13
|
|
vesrlv,"vector element shift right logical reg","not implemented",z13
|
|
vpklsfs,"vector pack logical saturate word","not implemented",z13
|
|
vcdgb,"vector fp convert from fixed 64 bit","not implemented",z13
|
|
verll,"vector element rotate left logical mem","not implemented",z13
|
|
vfeezf,"vector find element equal word","not implemented",z13
|
|
wclgdb,"vector fp convert to logical 64 bit","not implemented",z13
|
|
vgfma,"vector galois field multiply sum and accumulate","not implemented",z13
|
|
vmob,"vector multiply odd byte","not implemented",z13
|
|
vfeneb,"vector find element not equal byte","not implemented",z13
|
|
vfene,"vector find element not equal","not implemented",z13
|
|
vfenezfs,"vector find element not equal word","not implemented",z13
|
|
vmal,"vector multiply and add low","not implemented",z13
|
|
vfchdb,"vector fp compare high long","not implemented",z13
|
|
vfeezb,"vector find element equal byte","not implemented",z13
|
|
vfae,"vector find any element equal","not implemented",z13
|
|
vfchdbs,"vector fp compare high long","not implemented long",z13
|
|
vsceg,"vector scatter element 8 byte",implemented,z13
|
|
vfeezfs,"vector find element equal word","not implemented",z13
|
|
vsumgf,"vector sum across doubleword - word","not implemented",z13
|
|
vmnb,"vector minimum byte","not implemented",z13
|
|
vlef,"vector load word element",implemented,z13
|
|
vceqgs,"vector compare equal double word","not implemented",z13
|
|
vech,"vector element compare half word","not implemented",z13
|
|
vctz,"vector count trailing zeros","not implemented",z13
|
|
vmloh,"vector multiply logical odd halfword","not implemented",z13
|
|
vaccc,"vector add with carry compute carry","not implemented",z13
|
|
vmale,"vector multiply and add logical even","not implemented",z13
|
|
vsteh,"vector store halfword element",implemented,z13
|
|
vceq,"vector compare equal","not implemented",z13
|
|
vfchedbs,"vector fp compare high or equal long","not implemented",z13
|
|
vesl,"vector element shift left mem","not implemented",z13
|
|
vesrav,"vector element shift right arithmetic reg","not implemented",z13
|
|
vfma,"vector fp multiply and add","not implemented",z13
|
|
vmnlg,"vector minimum logical doubleword","not implemented",z13
|
|
vclz,"vector count leading zeros","not implemented",z13
|
|
vmrlf,"vector merge low word",implemented,z13
|
|
vistrh,"vector isolate string halfword","not implemented",z13
|
|
vmxlb,"vector maximum logical byte","not implemented",z13
|
|
vfs,"vector fp subtract","not implemented",z13
|
|
vfm,"vector fp multiply","not implemented",z13
|
|
vll,"vector load with length",implemented,z13
|
|
vleig,"vector load double word element immediate",implemented,z13
|
|
vfaezbs,"vector find any element equal","not implemented",z13
|
|
veslvg,"vector element shift left reg doubleword","not implemented",z13
|
|
locfh,"load high on condition from memory","not implemented",z13
|
|
vfeeb,"vector find element equal byte","not implemented",z13
|
|
vsumq,"vector sum across quadword","not implemented",z13
|
|
vmleb,"vector multiply logical even byte","not implemented",z13
|
|
vesrag,"vector element shift right arithmetic mem doubleword","not implemented",z13
|
|
vceqh,"vector compare equal half word","not implemented",z13
|
|
vmalf,"vector multiply and add low word","not implemented",z13
|
|
vstrchs,"vector string range compare halfword","not implemented",z13
|
|
vcgdb,"vector fp convert to fixed 64 bit","not implemented",z13
|
|
vsq,"vector subtract quadword","not implemented",z13
|
|
vnot,"vector not","not implemented",z13
|
|
vfch,"vector fp compare high","not implemented",z13
|
|
lochi,"load halfword immediate on condition into 32 bit gpr","not implemented",z13
|
|
verllvh,"vector element rotate left logical reg halfword","not implemented",z13
|
|
cpdt,"convert from long dfp to packed","not implemented",z13
|
|
vrepb,"vector replicate byte","implemented",z13
|
|
ppno,"perform pseudorandom number operation","not implemented",z13
|
|
vfeef,"vector find element equal word","not implemented",z13
|
|
vac,"vector add with carry","not implemented",z13
|
|
verimf,"vector element rotate and insert under mask word","not implemented",z13
|
|
vfi,"vector load fp integer","not implemented",z13
|
|
vistrfs,"vector isolate string word","not implemented",z13
|
|
vecf,"vector element compare word","not implemented",z13
|
|
vfeezbs,"vector find element equal byte","not implemented",z13
|
|
wflndb,"vector fp perform sign operation long","not implemented",z13
|
|
vscbif,"vector subtract compute borrow indication word","not implemented",z13
|
|
vchhs,"vector compare high half word","not implemented",z13
|
|
vmlb,"vector multiply low byte","not implemented",z13
|
|
veslvf,"vector element shift left reg word","not implemented",z13
|
|
vfaefs,"vector find any element equal","not implemented",z13
|
|
vlrep,"vector load and replicate",implemented,z13
|
|
vaccf,"vector add compute carry word","not implemented",z13
|
|
vpksf,"vector pack saturate word",implemented,z13
|
|
vavglf,"vector average logical word","not implemented",z13
|
|
vmef,"vector multiply even word","not implemented",z13
|
|
vuplhh,"vector unpack logical high halfword",implemented,z13
|
|
vmxl,"vector maximum logical","not implemented",z13
|
|
vgfmah,"vector galois field multiply sum and accumulate halfword","not implemented",z13
|
|
vmalhf,"vector multiply and add logical high word","not implemented",z13
|
|
vsh,"vector subtract halfword","not implemented",z13
|
|
vuplb,"vector unpack low byte",implemented,z13
|
|
vsegf,"vector sign extend word to double word",implemented,z13
|
|
vmxlf,"vector maximum logical word","not implemented",z13
|
|
wcdlgb,"vector fp convert from logical 64 bit","not implemented",z13
|
|
vstrczb,"vector string range compare byte","not implemented",z13
|
|
vsldb,"vector shift left double by byte","not implemented",z13
|
|
vesrlh,"vector element shift right logical mem halfword","not implemented",z13
|
|
cdpt,"convert from packed to long dfp","not implemented",z13
|
|
vlcb,"vector load complement byte","not implemented",z13
|
|
wfpsodb,"vector fp perform sign operation long","not implemented",z13
|
|
vsum,"vector sum across word","not implemented",z13
|
|
vfeehs,"vector find element equal halfword","not implemented",z13
|
|
vml,"vector multiply low","not implemented",z13
|
|
vuphh,"vector unpack high halfword",implemented,z13
|
|
vavglb,"vector average logical byte","not implemented",z13
|
|
vmlf,"vector multiply low word","not implemented",z13
|
|
wledb,"vector fp load rounded long to short","not implemented",z13
|
|
vstrcfs,"vector string range compare word","not implemented",z13
|
|
wcgdb,"vector fp convert to fixed 64 bit","not implemented",z13
|
|
vlph,"vector load positive halfword","not implemented",z13
|
|
vfenezf,"vector find element not equal word","not implemented",z13
|
|
vseg,"vector sign extend to double word",implemented,z13
|
|
vcksm,"vector checksum","not implemented",z13
|
|
vsrlb,"vector shift right logical by byte","not implemented",z13
|
|
verimg,"vector element rotate and insert under mask doubleword","not implemented",z13
|
|
vesravg,"vector element shift right arithmetic reg doubleword","not implemented",z13
|
|
vmlhh,"vector multiply logical high halfword","not implemented",z13
|
|
vfaezf,"vector find any element equal","not implemented",z13
|
|
vfenehs,"vector find element not equal halfword","not implemented",z13
|
|
vlr,"vector register load","implemented",z13
|
|
vgbm,"vector generate byte mask","implemented",z13
|
|
vmnlf,"vector minimum logical word","not implemented",z13
|
|
vlm,"vector load multiple","implemented",z13
|
|
vmrlb,"vector merge low byte","implemented",z13
|
|
vavglh,"vector average logical half word","not implemented",z13
|
|
wfkdb,"vector fp compare and signal scalar","not implemented",z13
|
|
veslb,"vector element shift left mem byte","not implemented",z13
|
|
wfchedb,"vector fp compare high or equal","not implemented",z13
|
|
vllezg,"vector load logical double word element and zero","implemented",z13
|
|
vmaob,"vector multiply and add odd byte","not implemented",z13
|
|
vmrhf,"vector merge high word","not implemented",z13
|
|
vchg,"vector compare high double word","not implemented",z13
|
|
locfhr,"load high on condition from gpr","not implemented",z13
|
|
vlpg,"vector load positive doubleword","not implemented",z13
|
|
vcdlgb,"vector fp convert from logical 64 bit","not implemented",z13
|
|
vstrczhs,"vector string range compare halfword","not implemented",z13
|
|
vecb,"vector element compare byte","not implemented",z13
|
|
vmxlg,"vector maximum logical doubleword","not implemented",z13
|
|
vfpso,"vector fp perform sign operation","not implemented",z13
|
|
verim,"vector element rotate and insert under mask","not implemented",z13
|
|
vsumqf,"vector sum across quadword - word elements","not implemented",z13
|
|
vfeefs,"vector find element equal word","not implemented",z13
|
|
vfche,"vector fp compare high or equal","not implemented",z13
|
|
vistrhs,"vector isolate string halfword","not implemented",z13
|
|
vsl,"vector shift left","not implemented",z13
|
|
vfenezhs,"vector find element not equal halfword","not implemented",z13
|
|
vsg,"vector subtract doubleword","not implemented",z13
|
|
vclzf,"vector count leading zeros word","not implemented",z13
|
|
wfcdb,"vector fp compare scalar long","not implemented",z13
|
|
vmaoh,"vector multiply and add odd halfword","not implemented",z13
|
|
vchgs,"vector compare high double word","not implemented",z13
|
|
vchlf,"vector compare high logical word","not implemented",z13
|
|
va,"vector add","not implemented",z13
|
|
vmrlg,"vector merge low double word",implemented,z13
|
|
vlcg,"vector load complement doubleword","not implemented",z13
|
|
vceqf,"vector compare equal word","not implemented",z13
|
|
vacq,"vector add with carry quadword","not implemented",z13
|
|
vmaof,"vector multiply and add odd word","not implemented",z13
|
|
vfadb,"vector fp add long","not implemented",z13
|
|
vmlef,"vector multiply logical even word","not implemented",z13
|
|
wfc,"vector fp compare scalar","not implemented",z13
|
|
vmx,"vector maximum","not implemented",z13
|
|
vmlh,"vector multiply logical high","not implemented",z13
|
|
vmeb,"vector multiply even byte","not implemented",z13
|
|
vfddb,"vector fp divide long","not implemented",z13
|
|
vpkshs,"vector pack saturate halfword","not implemented",z13
|
|
vpkf,"vector pack word","not implemented",z13
|
|
vlrepg,"vector load and replicate double word elements",implemented,z13
|
|
vmaef,"vector multiply and add even word","not implemented",z13
|
|
vfeneh,"vector find element not equal halfword","not implemented",z13
|
|
vgfmaf,"vector galois field multiply sum and accumulate word","not implemented",z13
|
|
vctzg,"vector count trailing zeros doubleword","not implemented",z13
|
|
lzrg,"load and zero rightmost byte 64->64","not implemented",z13
|
|
vmof,"vector multiply odd word","not implemented",z13
|
|
vfsqdb,"vector fp square root long","not implemented",z13
|
|
vlgvg,"vector load gr from vr double word element",implemented,z13
|
|
verllf,"vector element rotate left logical mem word","not implemented",z13
|
|
verllg,"vector element rotate left logical mem doubleword","not implemented",z13
|
|
vrepf,"vector replicate word",implemented,z13
|
|
vfeezhs,"vector find element equal halfword","not implemented",z13
|
|
wfchdbs,"vector fp compare high long","not implemented",z13
|
|
lochhi,"load halfword high immediate on condition","not implemented",z13
|
|
vmalhw,"vector multiply and add low halfword","not implemented",z13
|
|
vmlhb,"vector multiply logical high byte","not implemented",z13
|
|
vfeeh,"vector find element equal halfword","not implemented",z13
|
|
vgm,"vector generate mask",implemented,z13
|
|
vgfmab,"vector galois field multiply sum and accumulate byte","not implemented",z13
|
|
vmrhg,"vector merge high double word","not implemented",z13
|
|
veclg,"vector element compare logical double word","not implemented",z13
|
|
vl,"vector memory load",implemented,z13
|
|
vctzh,"vector count trailing zeros halfword","not implemented",z13
|
|
vuplhf,"vector unpack logical high word",implemented,z13
|
|
verllvg,"vector element rotate left logical reg doubleword","not implemented",z13
|
|
vupl,"vector unpack low",implemented,z13
|
|
vlgvb,"vector load gr from vr byte element",implemented,z13
|
|
vab,"vector add byte","not implemented",z13
|
|
vch,"vector compare high","not implemented",z13
|
|
veclf,"vector element compare logical word","not implemented",z13
|
|
vgef,"vector gather element 4 byte elements",implemented,z13
|
|
vscbiq,"vector subtract compute borrow indication quadword","not implemented",z13
|
|
cdgtr,"convert from fixed long dfp","not implemented",z13
|
|
vesrab,"vector element shift right arithmetic mem byte","not implemented",z13
|
|
vfsq,"vector fp square root","not implemented",z13
|
|
vscef,"vector scatter element 4 byte",implemented,z13
|
|
vpkh,"vector pack halfword","not implemented",z13
|
|
vfa,"vector fp add","not implemented",z13
|
|
vo,"vector or",implemented,z13
|
|
verllb,"vector element rotate left logical mem byte","not implemented",z13
|
|
stocfh,"store high on condition","not implemented",z13
|
|
vchlbs,"vector compare high logical byte","not implemented",z13
|
|
vuphf,"vector unpack high word",implemented,z13
|
|
vacc,"vector add compute carry","not implemented",z13
|
|
vistrf,"vector isolate string word","not implemented",z13
|
|
vceqhs,"vector compare equal half word","not implemented",z13
|
|
vfidb,"vector load fp integer long","not implemented",z13
|
|
vupllh,"vector unpack logical low halfword",implemented,z13
|
|
vfce,"vector fp compare equal","not implemented",z13
|
|
vs,"vector subtract","not implemented",z13
|
|
vfeebs,"vector find element equal byte","not implemented",z13
|
|
vlvgg,"vector load VR double word element from GR",implemented,z13
|
|
vbperm,"vector bit permute","not implemented",arch12
|
|
vllezlf,"vector load logical word element and zero - left aligned","not implemented","arch12"
|
|
vmsl,"vector multiply sum logical","not implemented","arch12"
|
|
vmslg,"vector multiply sum logical double word","not implemented","arch12"
|
|
vnx,"vector not exclusive or","not implemented","arch12"
|
|
vnn,"vector nand","not implemented","arch12"
|
|
voc,"vector or with complement","not implemented","arch12"
|
|
vpopctb,"vector population count byte","not implemented","arch12"
|
|
vpopcth,"vector population count halfword","not implemented","arch12"
|
|
vpopctf,"vector population count word","not implemented","arch12"
|
|
vpopctg,"vector population count double word","not implemented","arch12"
|
|
vfasb,"vector fp add short","not implemented","arch12"
|
|
wfasb,"scalar vector fp add scalar short","not implemented","arch12"
|
|
wfaxb,"scalar vector fp add scalar extended","not implemented","arch12"
|
|
wfcsb,"scalar vector fp compare scalar short","not implemented","arch12"
|
|
wfcxb,"scalar vector fp compare scalar extended","not implemented","arch12"
|
|
wfksb,"scalar vector fp compare and signal scalar short","not implemented","arch12"
|
|
wfkxb,"scalar vector fp compare and signal scalar extended","not implemented","arch12"
|
|
vfcesb,"vector fp compare equal short","not implemented","arch12"
|
|
vfcesbs,"vector fp compare equal short","not implemented","arch12"
|
|
wfcesb,"scalar vector fp compare equal scalar short","not implemented","arch12"
|
|
wfcesbs,"scalar fp compare equal scalar short","not implemented","arch12"
|
|
wfcexb,"scalar vector fp compare equal scalar extended","not implemented","arch12"
|
|
wfcexbs,"scalar vector fp compare equal scalar extended","not implemented","arch12"
|
|
vfkesb,"vector fp compare and signal equal short","not implemented","arch12"
|
|
vfkesbs,"vector fp compare and signal equal short","not implemented","arch12"
|
|
wfkesb,"scalar vector fp compare and signal equal scalar short","not implemented","arch12"
|
|
wfkesbs,"scalar fp compare and signal equal scalar short","not implemented","arch12"
|
|
vfkedb,"vector fp compare and signal equal long","not implemented","arch12"
|
|
vfkedbs,"vector fp compare and signal equal long","not implemented","arch12"
|
|
wfkedb,"vector fp compare and signal equal long","not implemented","arch12"
|
|
wfkedbs,"vector fp compare and signal equal long","not implemented","arch12"
|
|
wfkexb,"scalar vector fp compare and signal equal scalar extended","not implemented","arch12"
|
|
wfkexbs,"scalar vector fp compare and signal equal scalar extended","not implemented","arch12"
|
|
vfchsb,"vector fp compare high short","not implemented","arch12"
|
|
vfchsbs,"vector fp compare high short","not implemented","arch12"
|
|
wfchsb,"scalar vector fp compare high scalar short","not implemented","arch12"
|
|
wfchsbs,"scalar vector fp compare high scalar short","not implemented","arch12"
|
|
wfchxb,"scalar vector fp compare high scalar extended","not implemented","arch12"
|
|
wfchxbs,"scalar vector fp compare high scalar extended","not implemented","arch12"
|
|
vfkhsb,"vector fp compare and signal high short","not implemented","arch12"
|
|
vfkhsbs,"vector fp compare and signal high short","not implemented","arch12"
|
|
wfkhsb,"scalar vector fp compare and signal high scalar short","not implemented","arch12"
|
|
wfkhsbs,"scalar vector fp compare and signal high scalar short","not implemented","arch12"
|
|
vfkhdb,"vector fp compare and signal high long","not implemented","arch12"
|
|
vfkhdbs,"vector fp compare and signal high long","not implemented","arch12"
|
|
wfkhdb,"vector fp compare and signal high long","not implemented","arch12"
|
|
wfkhdbs,"vector fp compare and signal high long","not implemented","arch12"
|
|
wfkhxb,"scalar vector fp compare and signal high scalar extended","not implemented","arch12"
|
|
wfkhxbs,"scalar vector fp compare and signal high scalar extended","not implemented","arch12"
|
|
vfchesb,"vector fp compare high or equal short","not implemented","arch12"
|
|
vfchesbs,"vector fp compare high or equal short","not implemented","arch12"
|
|
wfchesb,"scalar vector fp compare high or equal scalar short","not implemented","arch12"
|
|
wfchesbs,"scalar vector fp compare high or equal scalar short","not implemented","arch12"
|
|
wfchexb,"scalar vector fp compare high or equal scalar extended","not implemented","arch12"
|
|
wfchexbs,"scalar vector fp compare high or equal scalar extended","not implemented","arch12"
|
|
vfkhesb,"vector fp compare and signal high or equal short","not implemented","arch12"
|
|
vfkhesbs,"vector fp compare and signal high or equal short","not implemented","arch12"
|
|
wfkhesb,"scalar vector fp compare and signal high or equal scalar short","arch12"implemented","arch12"
|
|
wfkhesbs,"scalar vector fp compare and signal high or equal scalar short","arch12"implemented","arch12"
|
|
vfkhedb,"vector fp compare and signal high or equal long","not implemented","arch12"
|
|
vfkhedbs,"vector fp compare and signal high or equal long","not implemented","arch12"
|
|
wfkhedb,"vector fp compare and signal high or equal long","not implemented","arch12"
|
|
wfkhedbs,"vector fp compare and signal high or equal long","not implemented","arch12"
|
|
wfkhexb,"scalar vector fp compare and signal high or equal scalar extended","arch12"implemented","arch12"
|
|
wfkhexbs,"scalar vector fp compare and signal high or equal scalar extended","arch12"implemented","arch12"
|
|
vfdsb,"vector fp divide short","not implemented","arch12"
|
|
wfdsb,"scalar vector fp divide scalar short","not implemented","arch12"
|
|
wfdxb,"scalar vector fp divide scalar extended","not implemented","arch12"
|
|
vfisb,"vector load fp integer short","not implemented","arch12"
|
|
wfisb,"scalar vector load fp integer scalar short","not implemented","arch12"
|
|
wfixb,"scalar vector load fp integer scalar extended","not implemented","arch12"
|
|
vfll,"vector fp load lengthened","not implemented","arch12"
|
|
vflls,"vector fp load lengthened","not implemented","arch12"
|
|
wflls,"scalar vector fp load lengthened short","not implemented","arch12"
|
|
wflld,"scalar vector fp load lengthened long","not implemented","arch12"
|
|
vflr,"vector fp load rounded","not implemented","arch12"
|
|
vflrd,"vector fp load rounded long","not implemented","arch12"
|
|
wflrd,"scalar vector fp load rounded long","not implemented","arch12"
|
|
wflrx,"scalar vector fp load rounded extended","not implemented","arch12"
|
|
vfmax,"vector fp maximum","not implemented","arch12"
|
|
vfmaxsb,"vector fp maximum short","not implemented","arch12"
|
|
vfmaxdb,"vector fp maximum long","not implemented","arch12"
|
|
wfmaxsb,"scalar fp maximum scalar short","not implemented","arch12"
|
|
wfmaxdb,"scalar fp maximum scalar long","not implemented","arch12"
|
|
wfmaxxb,"scalar fp maximum scalar extended","not implemented","arch12"
|
|
vfmin,"vector fp minimum","not implemented","arch12"
|
|
vfminsb,"vector fp minimum short","not implemented","arch12"
|
|
vfmindb,"vector fp minimum long","not implemented","arch12"
|
|
wfminsb,"scalar fp minimum scalar short","not implemented","arch12"
|
|
wfmindb,"scalar fp minimum scalar long","not implemented","arch12"
|
|
wfminxb,"scalar fp minimum scalar extended","not implemented","arch12"
|
|
vfmsb,"vector fp multiply short","not implemented","arch12"
|
|
wfmsb,"scalar vector fp multiply scalar short","not implemented","arch12"
|
|
wfmxb,"scalar vector fp multiply scalar extended","not implemented","arch12"
|
|
vfmasb,"vector fp multiply and add short","not implemented","arch12"
|
|
wfmasb,"scalar vector fp multiply and add scalar short","not implemented","arch12"
|
|
wfmaxb,"scalar vector fp multiply and add scalar extended","not implemented","arch12"
|
|
vfmssb,"vector fp multiply and subtract short","not implemented","arch12"
|
|
wfmssb,"scalar vector fp multiply and subtract scalar short","not implemented","arch12"
|
|
wfmsxb,"scalar vector fp multiply and subtract scalar extended","not implemented","arch12"
|
|
vfnma,"vector fp negative multiply and add","not implemented","arch12"
|
|
vfnmasb,"vector fp negative multiply and add short","not implemented","arch12"
|
|
wfnmasb,"scalar vector fp negative multiply and add scalar short","not implemented","arch12"
|
|
vfnmadb,"vector fp negative multiply and add long","not implemented","arch12"
|
|
wfnmadb,"scalar vector fp negative multiply and add scalar long","not implemented","arch12"
|
|
wfnmaxb,"scalar vector fp negative multiply and add scalar extended","not implemented","arch12"
|
|
vfnms,"vector fp negative multiply and subtract","not implemented","arch12"
|
|
vfnmssb,"vector fp negative multiply and subtract short","not implemented","arch12"
|
|
wfnmssb,"scalar vector fp negative multiply and subtract scalar short","arch12"implemented","arch12"
|
|
vfnmsdb,"vector fp negative multiply and subtract long","not implemented","arch12"
|
|
wfnmsdb,"scalar vector fp negative multiply and subtract scalar long","not implemented","arch12"
|
|
wfnmsxb,"scalar vector fp negative multiply and subtract scalar extended","arch12"implemented","arch12"
|
|
vfpsosb,"vector fp perform sign operation short","not implemented","arch12"
|
|
wfpsosb,"scalar vector fp perform sign operation scalar short","not implemented","arch12"
|
|
vflcsb,"vector fp perform sign operation short","not implemented","arch12"
|
|
wflcsb,"scalar vector fp perform sign operation scalar short","not implemented","arch12"
|
|
vflnsb,"vector fp perform sign operation short","not implemented","arch12"
|
|
wflnsb,"scalar vector fp perform sign operation scalar short","not implemented","arch12"
|
|
vflpsb,"vector fp perform sign operation short","not implemented","arch12"
|
|
wflpsb,"scalar vector fp perform sign operation scalar short","not implemented","arch12"
|
|
wfpsoxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12"
|
|
wflcxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12"
|
|
wflnxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12"
|
|
wflpxb,"scalar vector fp perform sign operation scalar extended","not implemented","arch12"
|
|
vfsqsb,"vector fp square root short","not implemented","arch12"
|
|
wfsqsb,"scalar vector fp square root scalar short","not implemented","arch12"
|
|
wfsqxb,"scalar vector fp square root scalar extended","not implemented","arch12"
|
|
vfssb,"vector fp subtract short","not implemented","arch12"
|
|
wfssb,"scalar vector fp subtract scalar short","not implemented","arch12"
|
|
wfsxb,"scalar vector fp subtract scalar extended","not implemented","arch12"
|
|
vftcisb,"vector fp test data class immediate short","not implemented","arch12"
|
|
wftcisb,"scalar vector fp test data class immediate scalar short","not implemented","arch12"
|
|
wftcixb,"scalar vector fp test data class immediate scalar extended","not implemented","arch12"
|
|
agh,"add halfword to 64 bit value","not implemented","arch12"
|
|
bic,"branch indirect on condition","not implemented","arch12"
|
|
bi,"unconditional indirect branch","not implemented","arch12"
|
|
mgrk,"multiply 64x64reg -> 128","not implemented","arch12"
|
|
mg,"multiply 64x64mem -> 128","not implemented","arch12"
|
|
mgh,"multiply halfword 64x16mem -> 64","not implemented","arch12"
|
|
msrkc,"multiply single 32x32 -> 32","not implemented","arch12"
|
|
msgrkc,"multiply single 64x64 -> 64","not implemented","arch12"
|
|
msc,"multiply single 32x32mem -> 32","not implemented","arch12"
|
|
msgc,"multiply single 64x64mem -> 64","not implemented","arch12"
|
|
sgh,"subtract halfword from 64 bit value","not implemented","arch12"
|
|
vlrlr,"vector load rightmost with length","not implemented","arch12"
|
|
vlrl,"vector load rightmost with immediate length","not implemented","arch12"
|
|
vstrlr,"vector store rightmost with length","not implemented","arch12"
|
|
vstrl,"vector store rightmost with immediate length","not implemented","arch12"
|
|
vap,"vector add decimal","not implemented","arch12"
|
|
vcp,"vector compare decimal","not implemented","arch12"
|
|
vcvb,"vector convert to binary 32 bit","not implemented","arch12"
|
|
vcvbg,"vector convert to binary 64 bit","not implemented","arch12"
|
|
vcvd,"vector convert to decimal 32 bit","not implemented","arch12"
|
|
vcvdg,"vector convert to decimal 64 bit","not implemented","arch12"
|
|
vdp,"vector divide decimal","not implemented","arch12"
|
|
vlip,"vector load immediate decimal","not implemented","arch12"
|
|
vmp,"vector multiply decimal","not implemented","arch12"
|
|
vmsp,"vector multiply and shift decimal","not implemented","arch12"
|
|
vpkz,"vector pack zoned","not implemented","arch12"
|
|
vpsop,"vector perform sign operation decimal","not implemented","arch12"
|
|
vrp,"vector remainder decimal","not implemented","arch12"
|
|
vsdp,"vector shift and divide decimal","not implemented","arch12"
|
|
vsrp,"vector shift and round decimal","not implemented","arch12"
|
|
vsp,"vector subtract decimal","not implemented","arch12"
|
|
vtp,"vector test decimal","not implemented","arch12"
|
|
vupkz,"vector unpack zoned","not implemented","arch12"
|
|
lgg,"load guarded 64 bit","not implemented","arch12"
|
|
llgfsg,"load logical and shift guarded 64 bit","not implemented","arch12"
|
|
lgsc,"load guarded storage controls","not implemented","arch12"
|
|
stgsc,"store guarded storage controls","not implemented","arch12"
|
|
kma,"cipher message with galois counter mode","not implemented","arch12"
|