florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 1 | a,add,implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 2 | ad,"add normalized (long)","won't do","hfp instruction" |
| 3 | adr,"add normalized (long)","won't do","hfp instruction" |
| 4 | ae,"add normalized (short)","won't do","hfp instruction" |
| 5 | aer,"add normalized (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 6 | ah,"add halfword",implemented, |
| 7 | al,"add logical",implemented, |
| 8 | alr,"add logical",implemented, |
| 9 | ap,"add decimal","not implemented", |
| 10 | ar,add,implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 11 | au,"add unnormalized (short)","won't do","hfp instruction" |
| 12 | aur,"add unnormalized (short)","won't do","hfp instruction" |
| 13 | aw,"add unnormalized (long)","won't do","hfp instruction" |
| 14 | awr,"add unnormalized (long)","won't do","hfp instruction" |
| 15 | axr,"add normalized","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 16 | bakr,"branch and stack","not implemented", |
| 17 | bal,"branch and link","not implemented", |
| 18 | balr,"branch and link","not implemented", |
| 19 | bas,"branch and save",implemented, |
| 20 | basr,"branch and save",implemented, |
| 21 | bassm,"branch and save and set mode","not implemented", |
| 22 | bc,"branch on condition",implemented, |
| 23 | bcr,"branch on condition",implemented, |
| 24 | bct,"branch on count",implemented, |
| 25 | bctr,"branch on count",implemented, |
| 26 | bsg,"branch in subspace group","not implemented", |
| 27 | bsm,"branch and set mode","not implemented", |
| 28 | bxh,"branch on index high",implemented, |
| 29 | bxle,"branch on index low or equal",implemented, |
| 30 | c,compare,implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 31 | cd,"compare (long)","won't do","hfp instruction" |
| 32 | cdr,"compare (long)","won't do","hfp instruction" |
florian | cc58cef | 2012-06-06 02:27:51 +0000 | [diff] [blame] | 33 | cds,"compare double and swap",implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 34 | ce,"compare (short)","won't do","hfp instruction" |
| 35 | cer,"compare (short)","won't do","hfp instruction" |
florian | 147e0a9 | 2012-03-19 13:22:21 +0000 | [diff] [blame] | 36 | cfc,"compare and form codeword","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 37 | ch,"compare halfword",implemented, |
| 38 | cl,"compare logical",implemented, |
| 39 | clc,"compare logical",implemented, |
| 40 | clcl,"compare logical long",implemented, |
| 41 | cli,"compare logical",implemented, |
| 42 | clm,"compare logical characters under mask",implemented, |
| 43 | clr,"compare logical",implemented, |
| 44 | clst,"compare logical string",implemented, |
| 45 | cp,"compare decimal","not implemented", |
| 46 | cpya,"copy access",implemented, |
| 47 | cr,compare,implemented, |
| 48 | cs,"compare and swap",implemented, |
| 49 | csch,"clear subchannel",N/A,"privileged instruction" |
| 50 | cuse,"compare until substring equal","not implemented", |
| 51 | csp,"compare and swap and purge",N/A,"privileged instruction" |
| 52 | cvb,"convert to binary",implemented, |
| 53 | cvd,"convert to decimal",implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 54 | cxr,"compare extended hfp","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 55 | d,divide,implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 56 | dd,"divide (long)","won't do","hfp instruction" |
| 57 | ddr,"divide (long)","won't do","hfp instruction" |
| 58 | de,"divide (short)","won't do","hfp instruction" |
| 59 | der,"divide (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 60 | diag,diagnose,N/A,"privileged instruction" |
| 61 | dp,"divide decimal","not implemented", |
| 62 | dr,divide,implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 63 | dxr,"divide (ext.)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 64 | ear,"extract access",implemented, |
| 65 | ed,edit,"not implemented", |
| 66 | edmk,"edit and mark","not implemented", |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 67 | epar,"extract primary ASN",N/A,"privileged instruction" |
| 68 | epair,"extract primary ASN and instance",N/A,"privileged instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 69 | ereg,"extract stacked registers","not implemented", |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 70 | esar,"extract secondary ASN",N/A,"privileged instruction", |
| 71 | esair,"extract secondary ASN and instance,N/A,"privileged instruction", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 72 | esta,"extract stacked state","not implemented", |
| 73 | ex,execute,implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 74 | hdr,"halve (long)","won't do","hfp instruction" |
| 75 | her,"halve (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 76 | hsch,"halt subchannel",N/A,"privileged instruction" |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 77 | iac,"insert address space control",N/A,"privileged instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 78 | ic,"insert character",implemented, |
| 79 | icm,"insert characters under mask",implemented, |
| 80 | ipk,"insert PSW key",N/A,"privileged instruction" |
| 81 | ipm,"insert program mask",implemented, |
| 82 | ipte,"invalidate page table entry",N/A,"privileged instruction" |
| 83 | iske,"insert storage key extended",N/A,"privileged instruction" |
| 84 | ivsk,"insert virtual storage key",N/A,"privileged instruction" |
| 85 | l,load,implemented, |
| 86 | la,"load address",implemented, |
| 87 | lae,"load address extended",implemented, |
| 88 | lam,"load access multiple",implemented, |
| 89 | lasp,"load address space parameters",N/A,"privileged instruction" |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 90 | lcdr,"load complement (long)","won't do","hfp instruction" |
| 91 | lcer,"load complement (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 92 | lcr,"load complement",implemented, |
| 93 | lctl,"load control",N/A,"privileged instruction" |
| 94 | ld,"load (long)",implemented, |
| 95 | ldr,"load (long)",implemented, |
| 96 | le,"load (short)",implemented, |
| 97 | ler,"load (short)",implemented, |
| 98 | lh,"load halfword",implemented, |
| 99 | lm,"load multiple",implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 100 | lndr,"load negative (long)","won't do","hfp instruction" |
| 101 | lner,"load negative (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 102 | lnr,"load negative",implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 103 | lpdr,"load positive (long)","won't do","hfp instruction" |
| 104 | lper,"load positive (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 105 | lpr,"load positive",implemented, |
| 106 | lpsw,"load PSW",N/A,"privileged instruction" |
| 107 | lr,load,implemented, |
| 108 | lra,"load real address",N/A,"privileged instruction" |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 109 | ldxr,"load rounded (ext. to long)","won't do","hfp instruction" |
| 110 | ledr,"load rounded (long to short)","won't do","hfp instruction" |
| 111 | ltdr,"load and test (long)","won't do","hfp instruction" |
| 112 | lter,"load and test (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 113 | ltr,"load and test",implemented, |
| 114 | lura,"load using real address",N/A,"privileged instruction" |
| 115 | m,multiply,implemented, |
| 116 | mc,"monitor call","not implemented", |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 117 | md,"multiply (long)","won't do","hfp instruction" |
| 118 | mdr,"multiply (long)","won't do","hfp instruction" |
| 119 | mde,"multiply (short to long)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 120 | mder,"multiply short to long hfp","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 121 | mh,"multiply halfword",implemented, |
| 122 | mp,"multiply decimal","not implemented", |
| 123 | mr,multiply,implemented, |
| 124 | msch,"modify subchannel",N/A,"privileged instruction" |
| 125 | msta,"modify stacked state","not implemented", |
| 126 | mvc,move,implemented, |
| 127 | mvcdk,"move with destination key",N/A,"privileged instruction" |
| 128 | mvcin,"move inverse","not implemented", |
| 129 | mvck,"move with key",N/A,"privileged instruction" |
| 130 | mvcl,"move long",implemented, |
| 131 | mvcp,"move to primary",N/A,"privileged instruction" |
| 132 | mvcs,"move to secondary",N/A,"privileged instruction" |
| 133 | mvcsk,"move with source key","not implemented", |
| 134 | mvi,move,implemented, |
| 135 | mvn,"move numerics","not implemented", |
| 136 | mvo,"move with offset","not implemented", |
| 137 | mvpg,"move page",N/A,"privileged instruction" |
| 138 | mvst,"move string",implemented, |
| 139 | mvz,"move zones","not implemented", |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 140 | mxd,"multiply (long to ext.)","won't do","hfp instruction" |
| 141 | mxdr,"multiply (long to ext.)","won't do","hfp instruction" |
| 142 | mxr,"multiply (ext.)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 143 | n,AND,implemented, |
| 144 | nc,AND,implemented, |
| 145 | ni,AND,implemented, |
| 146 | nr,AND,implemented, |
| 147 | o,OR,implemented, |
| 148 | oc,OR,implemented, |
| 149 | oi,OR,implemented, |
| 150 | or,OR,implemented, |
| 151 | pack,pack,"not implemented", |
| 152 | palb,"purge ALB",N/A,"privileged instruction" |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 153 | pc,"program call",N/A,"privileged instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 154 | pr,"program return","not implemented", |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 155 | pt,"program transfer",N/A,"privileged instruction", |
| 156 | pti,"program transfer with instance",N/A,"privileged instruction", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 157 | ptlb,"purge TLB",N/A,"privileged instruction" |
| 158 | rchp,"reset channel path",N/A,"privileged instruction" |
| 159 | rrbe,"reset reference bit extended",N/A,"privileged instruction" |
| 160 | rsch,"resume subchannel",N/A,"privileged instruction" |
| 161 | s,subtract,implemented, |
| 162 | sac,"set address space control",N/A,"privileged instruction" |
| 163 | sacf,"set address space control fast",N/A,"privileged instruction" |
| 164 | sal,"set address limit",N/A,"privileged instruction" |
| 165 | sar,"set access",implemented, |
| 166 | schm,"set channel monitor",N/A,"privileged instruction" |
| 167 | sck,"set clock",N/A,"privileged instruction" |
| 168 | sckc,"set clock comparator",N/A,"privileged instruction" |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 169 | sd,"subtract normalized (long)","won't do","hfp instruction" |
| 170 | sdr,"subtract normalized (long)","won't do","hfp instruction" |
| 171 | se,"subtract normalized (short)","won't do","hfp instruction" |
| 172 | ser,"subtract normalized (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 173 | sh,"subtract halfword",implemented, |
| 174 | sie,"start interpretive execution","not implemented", |
| 175 | sigp,"signal processor",N/A,"privileged instruction" |
| 176 | sl,"subtract logical",implemented, |
| 177 | sla,"shift left single",implemented, |
| 178 | slda,"shift left double (long)",implemented, |
| 179 | sldl,"shift left double logical (long)",implemented, |
| 180 | sll,"shift left single logical",implemented, |
| 181 | slr,"subtract logical",implemented, |
| 182 | sp,"subtract decimal","not implemented", |
| 183 | spka,"set PSW key from address",N/A,"privileged instruction" |
florian | 147e0a9 | 2012-03-19 13:22:21 +0000 | [diff] [blame] | 184 | spm,"set program mask","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 185 | spt,"set CPU timer",N/A,"privileged instruction" |
| 186 | spx,"set prefix",N/A,"privileged instruction" |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 187 | sqdr,"square root (long)","won't do","hfp instruction" |
| 188 | sqer,"square root (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 189 | sr,subtract,implemented, |
| 190 | sra,"shift right single",implemented, |
| 191 | srda,"shift right double (long)",implemented, |
| 192 | srdl,"shift right double logical (long)",implemented, |
| 193 | srl,"shift right single logical",implemented, |
| 194 | srp,"shift and round decimal","not implemented", |
| 195 | srst,"search string",implemented, |
| 196 | ssar,"set secondary ASN","not implemented", |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 197 | ssair,"set secondary ASN with instance","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 198 | ssch,"start subchannel",N/A,"privileged instruction" |
| 199 | sske,"set storage key extended",N/A,"privileged instruction" |
| 200 | ssm,"set system mask",N/A,"privileged instruction" |
| 201 | st,store,implemented, |
| 202 | stam,"store access multiple",implemented, |
| 203 | stap,"store CPU address",N/A,"privileged instruction" |
| 204 | stc,"store character",implemented, |
| 205 | stck,"store clock",implemented, |
| 206 | stckc,"store clock comparator",N/A,"privileged instruction" |
| 207 | stcm,"store characters under mask",implemented, |
| 208 | stcps,"store channel path status",N/A,"privileged instruction" |
| 209 | stcrw,"store channel report word",N/A,"privileged instruction" |
| 210 | stctl,"store control",N/A,"privileged instruction" |
| 211 | std,"store (long)",implemented, |
| 212 | ste,"store (short)",implemented, |
| 213 | sth,"store halfword",implemented, |
| 214 | stidp,"store CPU id",N/A,"privileged instruction" |
| 215 | stm,"store multiple",implemented, |
| 216 | stnsm,"store then AND system mask",N/A,"privileged instruction" |
| 217 | stosm,"store then OR system mask",N/A,"privileged instruction" |
| 218 | stpt,"store CPU timer",N/A,"privileged instruction" |
| 219 | stpx,"store prefix",N/A,"privileged instruction" |
| 220 | stsch,"store subchannel",N/A,"privileged instruction" |
| 221 | stura,"store using real address",N/A,"privileged instruction" |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 222 | su,"subtract unnormalized (short)","won't do","hfp instruction" |
| 223 | sur,"subtract unnormalized (short)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 224 | svc,"supervisor call",implemented, |
florian | 4ed2889 | 2012-09-18 21:15:54 +0000 | [diff] [blame] | 225 | sw,"subtract unnormalized (long)","won't do","hfp instruction" |
| 226 | swr,"subtract unnormalized (long)","won't do","hfp instruction" |
| 227 | sxr,"subtract normalized (ext.)","won't do","hfp instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 228 | tar,"test access","not implemented", |
| 229 | tb,"test block",N/A,"privileged instruction" |
| 230 | tm,"test under mask",implemented, |
| 231 | tpi,"test pending interruption",N/A,"privileged instruction" |
| 232 | tprot,"test protection",N/A,"privileged instruction" |
| 233 | tr,translate,implemented, |
| 234 | trace,trace,N/A,"privileged instruction" |
florian | 147e0a9 | 2012-03-19 13:22:21 +0000 | [diff] [blame] | 235 | trt,"translate and test","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 236 | ts,"test and set","won't do","deprecated instruction" |
| 237 | tsch,"test subchannel",N/A,"privileged instruction" |
| 238 | unpk,unpack,"not implemented", |
florian | 147e0a9 | 2012-03-19 13:22:21 +0000 | [diff] [blame] | 239 | upt,"update tree","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 240 | x,"exclusive OR",implemented, |
| 241 | xc,"exclusive OR",implemented, |
| 242 | xi,"exclusive OR",implemented, |
| 243 | xr,"exclusive OR",implemented, |
| 244 | zap,"zero and add","not implemented", |
| 245 | ahi,"add halfword immediate",implemented, |
| 246 | brxh,"branch relative on index high",implemented, |
| 247 | brxle,"branch relative on index low or equal",implemented, |
| 248 | bras,"branch relative and save",implemented, |
| 249 | brc,"branch relative on condition",implemented, |
| 250 | brct,"branch relative on count",implemented, |
| 251 | cksm,checksum,implemented, |
| 252 | chi,"compare halfword immediate",implemented, |
| 253 | clcle,"compare logical long extended",implemented, |
| 254 | lhi,"load halfword immediate",implemented, |
| 255 | mvcle,"move long extended",implemented, |
| 256 | mhi,"multiply halfword immediate",implemented, |
| 257 | msr,"multiply single",implemented, |
| 258 | ms,"multiply single",implemented, |
| 259 | tmlh,"test under mask low high",implemented, |
| 260 | tmll,"test under mask low low",implemented, |
| 261 | axbr,"add extended bfp",implemented, |
| 262 | adbr,"add long bfp",implemented, |
| 263 | adb,"add long bfp",implemented, |
| 264 | aebr,"add short bfp",implemented, |
| 265 | aeb,"add short bfp",implemented, |
| 266 | cxbr,"compare extended bfp",implemented, |
| 267 | cdbr,"compare long bfp",implemented, |
| 268 | cdb,"compare long bfp",implemented, |
| 269 | cebr,"compare short bfp",implemented, |
| 270 | ceb,"compare short bfp",implemented, |
| 271 | kxbr,"compare and signal extended bfp","not implemented", |
| 272 | kdbr,"compare and signal long bfp","not implemented", |
| 273 | kdb,"compare and signal long bfp","not implemented", |
| 274 | kebr,"compare and signal short bfp","not implemented", |
| 275 | keb,"compare and signal short bfp","not implemented", |
| 276 | cxfbr,"convert from fixed 32 to extended bfp",implemented, |
| 277 | cdfbr,"convert from fixed 32 to long bfp",implemented, |
| 278 | cefbr,"convert from fixed 32 to short bfp",implemented, |
| 279 | cfxbr,"convert to fixed extended bfp to 32",implemented, |
| 280 | cfdbr,"convert to fixed long bfp to 32",implemented, |
| 281 | cfebr,"convert to fixed short bfp to 32",implemented, |
| 282 | dxbr,"divide extended bfp",implemented, |
| 283 | ddbr,"divide long bfp",implemented, |
| 284 | ddb,"divide long bfp",implemented, |
| 285 | debr,"divide short bfp",implemented, |
| 286 | deb,"divide short bfp",implemented, |
| 287 | didbr,"divide to integer long bfp","not implemented", |
| 288 | diebr,"divide to integer short bfp","not implemented", |
| 289 | efpc,"extract fpc",implemented, |
| 290 | ltxbr,"load and test extended bfp",implemented, |
| 291 | ltdbr,"load and test long bfp",implemented, |
| 292 | ltebr,"load and test short bfp",implemented, |
| 293 | lcxbr,"load complement extended bfp",implemented, |
| 294 | lcdbr,"load complement long bfp",implemented, |
| 295 | lcebr,"load complement short bfp",implemented, |
| 296 | fixbr,"load fp integer extended bfp","not implemented", |
| 297 | fidbr,"load fp integer long bfp","not implemented", |
| 298 | fiebr,"load fp integer short bfp","not implemented", |
| 299 | lfpc,"load fpc",implemented, |
| 300 | lxdbr,"load lengthened long to extended bfp",implemented, |
| 301 | lxdb,"load lengthened long to extended bfp",implemented, |
| 302 | lxebr,"load lengthened short to extended bfp",implemented, |
| 303 | lxeb,"load lengthened short to extended bfp",implemented, |
| 304 | ldebr,"load lengthened short to long bfp",implemented, |
| 305 | ldeb,"load lengthened short to long bfp",implemented, |
| 306 | lnxbr,"load negative extended bfp",implemented, |
| 307 | lndbr,"load negative long bfp",implemented, |
| 308 | lnebr,"load negative short bfp",implemented, |
| 309 | lpxbr,"load positive extended bfp",implemented, |
| 310 | lpdbr,"load positive long bfp",implemented, |
| 311 | lpebr,"load positive short bfp",implemented, |
| 312 | ldxbr,"load rounded extended to long bfp",implemented, |
| 313 | lexbr,"load rounded extended to short bfp",implemented, |
| 314 | ledbr,"load rounded long to short bfp",implemented, |
| 315 | mxbr,"multiply extended bfp",implemented, |
| 316 | mdbr,"multiply long bfp",implemented, |
| 317 | mdb,"multiply long bfp",implemented, |
| 318 | mxdbr,"multiply long to extended bfp","not implemented", |
| 319 | mxdb,"multiply long to extended bfp","not implemented", |
| 320 | meebr,"multiply short bfp",implemented, |
| 321 | meeb,"multiply short bfp",implemented, |
| 322 | mdebr,"multiply short to long bfp","not implemented", |
| 323 | mdeb,"multiply short to long bfp","not implemented", |
| 324 | madbr,"multiply and add long bfp",implemented, |
| 325 | madb,"multiply and add long bfp",implemented, |
| 326 | maebr,"multiply and add short bfp",implemented, |
| 327 | maeb,"multiply and add short bfp",implemented, |
| 328 | msdbr,"multiply and subtract long bfp",implemented, |
| 329 | msdb,"multiply and subtract long bfp",implemented, |
| 330 | msebr,"multiply and subtract short bfp",implemented, |
| 331 | mseb,"multiply and subtract short bfp",implemented, |
| 332 | sfpc,"set fpc",implemented, |
| 333 | srnm,"set rounding mode",implemented, |
| 334 | sqxbr,"square root extended bfp",implemented, |
| 335 | sqdbr,"square root long bfp",implemented, |
| 336 | sqdb,"square root long bfp",implemented, |
| 337 | sqebr,"square root short bfp",implemented, |
| 338 | sqeb,"square root short bfp",implemented, |
| 339 | stfpc,"store fpc",implemented, |
| 340 | sxbr,"subtract extended bfp",implemented, |
| 341 | sdbr,"subtract long bfp",implemented, |
| 342 | sdb,"subtract long bfp",implemented, |
| 343 | sebr,"subtract short bfp",implemented, |
| 344 | seb,"subtract short bfp",implemented, |
| 345 | tcxb,"test data class extended bfp",implemented, |
| 346 | tcdb,"test data class long bfp",implemented, |
| 347 | tceb,"test data class short bfp",implemented, |
| 348 | siga,"signal adapter","not implemented", |
florian | 147e0a9 | 2012-03-19 13:22:21 +0000 | [diff] [blame] | 349 | plo,"perform locked operation","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 350 | bsa,"branch and set authority",N/A,"privileged instruction" |
| 351 | rp,"resume program",N/A,"privileged instruction" |
| 352 | sckpf,"set clock programmable field",N/A,"privileged instruction" |
| 353 | stsi,"store system information",N/A,"privileged instruction" |
| 354 | trap2,trap,"not implemented", |
| 355 | trap4,trap4,"not implemented", |
| 356 | stcke,"store clock extended",implemented, |
| 357 | tre,"translate extended",implemented, |
| 358 | mvclu,"move long unicode","not implemented", |
| 359 | pka,"pack ascii","not implemented", |
| 360 | pku,"pack unicode","not implemented", |
| 361 | troo,"translate one to one",implemented, |
| 362 | trot,"translate one to two",implemented, |
| 363 | trto,"translate two to one",implemented, |
| 364 | trtt,"translate two to two",implemented, |
| 365 | unpka,"unpack ascii","not implemented", |
| 366 | unpku,"unpack unicode","not implemented", |
| 367 | thder,"convert short bfp to long hfp","won't do","hfp instruction" |
| 368 | thdr,"convert long bfp to long hfp","won't do","hfp instruction" |
| 369 | tbedr,"convert long hfp to short bfp","won't do","hfp instruction" |
| 370 | tbdr,"convert long hfp to long bfp","won't do","hfp instruction" |
| 371 | lzer,"load short zero",implemented, |
| 372 | lzdr,"load long zero",implemented, |
| 373 | lzxr,"load extended zero",implemented, |
| 374 | bctgr,"branch on count 64",implemented, |
| 375 | lpgr,"load positive 64",implemented, |
| 376 | lpgfr,"load positive 64<32",implemented, |
| 377 | lngr,"load negative 64",implemented, |
| 378 | lngfr,"load negative 64<32",implemented, |
| 379 | ltgr,"load and test 64",implemented, |
| 380 | ltgfr,"load and test 64<32",implemented, |
| 381 | lcgr,"load complement 64",implemented, |
| 382 | lcgfr,"load complement 64<32",implemented, |
| 383 | ngr,"and 64",implemented, |
| 384 | clgr,"compare logical 64",implemented, |
| 385 | clgfr,"compare logical 64<32",implemented, |
| 386 | ogr,"or 64",implemented, |
| 387 | xgr,"exclusive or 64",implemented, |
| 388 | lgr,"load 64",implemented, |
| 389 | lgfr,"load 64<32",implemented, |
| 390 | cgr,"compare 64",implemented, |
| 391 | cgfr,"compare 64<32",implemented, |
| 392 | agr,"add 64",implemented, |
| 393 | agfr,"add 64<32",implemented, |
| 394 | sgr,"subtract 64",implemented, |
| 395 | sgfr,"subtract 64<32",implemented, |
| 396 | algr,"add logical 64",implemented, |
| 397 | algfr,"add logical 64<32",implemented, |
| 398 | slgr,"subtract logical 64",implemented, |
| 399 | slgfr,"subtract logical 64<32",implemented, |
| 400 | bctg,"branch on count 64",implemented, |
| 401 | cvdg,"convert to decimal 64","not implemented", |
| 402 | cvbg,"convert to binary 64","not implemented", |
| 403 | stg,"store 64",implemented, |
| 404 | ng,"and 64",implemented, |
| 405 | clg,"compare logical 64",implemented, |
| 406 | clgf,"compare logical 64<32",implemented, |
| 407 | og,"or 64",implemented, |
| 408 | xg,"exclusive or 64",implemented, |
| 409 | lg,"load 64",implemented, |
| 410 | lgf,"load 64<32",implemented, |
| 411 | lgh,"load halfword 64",implemented, |
| 412 | cg,"compare 64",implemented, |
| 413 | cgf,"compare 64<32",implemented, |
| 414 | ag,"add 64",implemented, |
| 415 | agf,"add 64<32",implemented, |
| 416 | sg,"subtract 64",implemented, |
| 417 | sgf,"subtract 64<32",implemented, |
| 418 | alg,"add logical 64",implemented, |
| 419 | algf,"add logical 64<32",implemented, |
| 420 | slg,"subtract logical 64",implemented, |
| 421 | slgf,"subtract logical 64<32",implemented, |
| 422 | msg,"multiply single 64",implemented, |
| 423 | msgf,"multiply single 64<32",implemented, |
| 424 | brxhg,"branch relative on index high 64",implemented, |
| 425 | brxlg,"branch relative on index low or equal 64",implemented, |
| 426 | bxhg,"branch on index high 64",implemented, |
| 427 | bxleg,"branch on index low or equal 64",implemented, |
| 428 | srlg,"shift right single logical 64",implemented, |
| 429 | sllg,"shift left single logical 64",implemented, |
| 430 | srag,"shift right single 64",implemented, |
| 431 | slag,"shift left single 64",implemented, |
| 432 | stmg,"store multiple 64",implemented, |
| 433 | stmh,"store multiple high",implemented, |
| 434 | lmg,"load multiple 64",implemented, |
| 435 | lmh,"load multiple high",implemented, |
| 436 | lmd,"load multiple disjoint","not implemented", |
| 437 | tracg,"trace 64",N/A,"privileged instruction" |
| 438 | lrag,"load real address 64",N/A,"privileged instruction" |
| 439 | strag,"store read address",N/A,"privileged instruction" |
| 440 | stctg,"store control 64",N/A,"privileged instruction" |
| 441 | lctlg,"load control 64",N/A,"privileged instruction" |
| 442 | csg,"compare and swap 64",implemented, |
florian | cc58cef | 2012-06-06 02:27:51 +0000 | [diff] [blame] | 443 | cdsg,"compare double and swap 64",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 444 | clmh,"compare logical characters under mask high",implemented, |
| 445 | stcmh,"store characters under mask high",implemented, |
| 446 | icmh,"insert characters under mask high",implemented, |
| 447 | tmhh,"test under mask high high",implemented, |
| 448 | tmhl,"test under mask high low",implemented, |
| 449 | brcl,"branch relative on condition long",implemented, |
| 450 | brasl,"branch relative and save long",implemented, |
| 451 | brctg,"branch relative on count 64",implemented, |
| 452 | lghi,"load halfword immediate 64",implemented, |
| 453 | aghi,"add halfword immediate 64",implemented, |
| 454 | mghi,"multiply halfword immediate 64",implemented, |
| 455 | cghi,"compare halfword immediate 64",implemented, |
| 456 | sturg,"store using real address 64",N/A,"privileged instruction" |
| 457 | eregg,"extract stacked registers 64","not implemented", |
| 458 | lurag,"load using real address 64",N/A,"privileged instruction" |
| 459 | msgr,"multiply single 64",implemented, |
| 460 | msgfr,"multiply single 64<32",implemented, |
| 461 | cegbr,"convert from fixed 64 to short bfp",implemented, |
| 462 | cdgbr,"convert from fixed 64 to long bfp",implemented, |
| 463 | cxgbr,"convert from fixed 64 to extended bfp",implemented, |
| 464 | cgebr,"convert to fixed short bfd to 64",implemented, |
| 465 | cgdbr,"convert to fixed long bfp to 64",implemented, |
| 466 | cgxbr,"convert to fixed extended bfp to 64",implemented, |
| 467 | cegr,"convert from fixed 64 to short hfp","won't do","hfp instruction" |
| 468 | cdgr,"convert from fixed 64 to long hfp","won't do","hfp instruction" |
| 469 | cxgr,"convert from fixed 64 to extended hfp","won't do","hfp instruction" |
| 470 | cger,"convert to fixed short hfp to 64","won't do","hfp instruction" |
| 471 | cgdr,"convert to fixed long hfp to 64","won't do","hfp instruction" |
| 472 | cgxr,"convert to fixed extended hfp to 64","won't do","hfp instruction" |
| 473 | tam,"test addressing mode","not implemented", |
| 474 | sam24,"set addressing mode 24","not implemented", |
| 475 | sam31,"set addressing mode 31","not implemented", |
| 476 | sam64,"set addressing mode 64","not implemented", |
| 477 | iihh,"insert immediate high high",implemented, |
| 478 | iihl,"insert immediate high low",implemented, |
| 479 | iilh,"insert immediate low high",implemented, |
| 480 | iill,"insert immediate low low",implemented, |
| 481 | nihh,"and immediate high high",implemented, |
| 482 | nihl,"and immediate high low",implemented, |
| 483 | nilh,"and immediate low high",implemented, |
| 484 | nill,"and immediate low low",implemented, |
| 485 | oihh,"or immediate high high",implemented, |
| 486 | oihl,"or immediate high low",implemented, |
| 487 | oilh,"or immediate low high",implemented, |
| 488 | oill,"or immediate low low",implemented, |
| 489 | llihh,"load logical immediate high high",implemented, |
| 490 | llihl,"load logical immediate high low",implemented, |
| 491 | llilh,"load logical immediate low high",implemented, |
| 492 | llill,"load logical immediate low low",implemented, |
| 493 | stfl,"store facility list",N/A,"privileged instruction" |
| 494 | lpswe,"load psw extended",N/A,"privileged instruction" |
| 495 | dsgr,"divide single 64",implemented, |
| 496 | lrvgr,"load reversed 64",implemented, |
| 497 | llgfr,"load logical 64<32",implemented, |
| 498 | llgtr,"load logical thirty one bits",implemented, |
| 499 | dsgfr,"divide single 64<32",implemented, |
| 500 | lrvr,"load reversed 32",implemented, |
| 501 | mlgr,"multiply logical 64",implemented, |
| 502 | dlgr,"divide logical 64",implemented, |
| 503 | alcgr,"add logical with carry 64",implemented, |
| 504 | slbgr,"subtract logical with borrow 64",implemented, |
| 505 | epsw,"extract psw","not implemented", |
| 506 | mlr,"multiply logical 32",implemented, |
| 507 | dlr,"divide logical 32",implemented, |
| 508 | alcr,"add logical with carry 32",implemented, |
| 509 | slbr,"subtract logical with borrow 32",implemented, |
| 510 | esea,"extract and set extended authority",N/A,"privileged instruction" |
| 511 | larl,"load address relative long",implemented, |
| 512 | dsg,"divide single 64",implemented, |
| 513 | lrvg,"load reversed 64",implemented, |
| 514 | llgf,"load logical 64<32",implemented, |
| 515 | llgt,"load logical thirty one bits",implemented, |
| 516 | dsgf,"divide single 64<32",implemented, |
| 517 | lrv,"load reversed 32",implemented, |
| 518 | lrvh,"load reversed 16",implemented, |
| 519 | strvg,"store reversed 64",implemented, |
| 520 | strv,"store reversed 32",implemented, |
| 521 | strvh,"store reversed 64",implemented, |
| 522 | mlg,"multiply logical 64",implemented, |
| 523 | dlg,"divide logical 64",implemented, |
| 524 | alcg,"add logical with carry 64",implemented, |
| 525 | slbg,"subtract logical with borrow 64",implemented, |
| 526 | stpq,"store pair to quadword",implemented, |
| 527 | lpq,"load pair from quadword",implemented, |
| 528 | ml,"multiply logical 32",implemented, |
| 529 | dl,"divide logical 32",implemented, |
| 530 | alc,"add logical with carry 32",implemented, |
| 531 | slb,"subtract logical with borrow 32",implemented, |
| 532 | llgc,"load logical character",implemented, |
| 533 | llgh,"load logical halfword",implemented, |
| 534 | rllg,"rotate left single logical 64",implemented, |
| 535 | rll,"rotate left single logical 32",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 536 | cxfr,"convert from fixed 32 to extended hfp","won't do","hfp instruction" |
| 537 | cdfr,"convert from fixed 32 to long hfp","won't do","hfp instruction" |
| 538 | cefr,"convert from fixed 32 to short hfp","won't do","hfp instruction" |
| 539 | cfxr,"convert to fixed extended hfp to 32","won't do","hfp instruction" |
| 540 | cfdr,"convert to fixed long hfp to 32","won't do","hfp instruction" |
| 541 | cfer,"convert to fixed short hfp to 32","won't do","hfp instruction" |
| 542 | ltxr,"load and test extended hfp","won't do","hfp instruction" |
| 543 | lcxr,"load complement extended hfp","won't do","hfp instruction" |
| 544 | fixr,"load fp integer extended hfp","won't do","hfp instruction" |
| 545 | fidr,"load fp integer long hfp","won't do","hfp instruction" |
| 546 | fier,"load fp integer short hfp","won't do","hfp instruction" |
| 547 | lxdr,"load lengthened long to extended hfp","won't do","hfp instruction" |
| 548 | lxd,"load lengthened long to extended hfp","won't do","hfp instruction" |
| 549 | lxer,"load lengthened short to extended hfp","won't do","hfp instruction" |
| 550 | lxe,"load lengthened short to extended hfp","won't do","hfp instruction" |
| 551 | lder,"load lengthened short to long hfp","won't do","hfp instruction" |
| 552 | lde,"load lengthened short to long hfp","won't do","hfp instruction" |
| 553 | lnxr,"load negative extended hfp","won't do","hfp instruction" |
| 554 | lpxr,"load positive extended hfp","won't do","hfp instruction" |
| 555 | lexr,"load rounded extended to short hfp","won't do","hfp instruction" |
| 556 | meer,"multiply short hfp","won't do","hfp instruction" |
| 557 | mee,"multiply short hfp","won't do","hfp instruction" |
| 558 | sqxr,"square root extended hfp","won't do","hfp instruction" |
| 559 | sqe,"square root short hfp","won't do","hfp instruction" |
| 560 | sqd,"square root long hfp","won't do","hfp instruction" |
| 561 | cmpsc,"compression call","not implemented", |
| 562 | tp,"test decimal","not implemented", |
| 563 | lxr,"load extended fp",implemented, |
| 564 | pgin,"page in",N/A,"privileged instruction" |
| 565 | pgout,"page out",N/A,"privileged instruction" |
| 566 | xsch,"cancel subchannel",N/A,"privileged instruction" |
| 567 | ay,"add with long offset",implemented, |
| 568 | ahy,"add halfword with long offset",implemented, |
| 569 | aly,"add logical with long offset",implemented, |
| 570 | niy,"and immediate with long offset",implemented, |
| 571 | ny,"and with long offset",implemented, |
| 572 | cy,"compare with long offset",implemented, |
| 573 | csy,"compare and swap with long offset",implemented, |
florian | cc58cef | 2012-06-06 02:27:51 +0000 | [diff] [blame] | 574 | cdsy,"compare double and swap with long offset",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 575 | chy,"compare halfword with long offset",implemented, |
| 576 | cly,"compare logical with long offset",implemented, |
| 577 | cliy,"compare logical immediate with long offset",implemented, |
| 578 | clmy,"compare logical characters under mask with long offset",implemented, |
| 579 | cvby,"convert to binary with long offset",implemented, |
| 580 | cvdy,"convert to decimal with long offset",implemented, |
| 581 | xiy,"exclusive or immediate with long offset",implemented, |
| 582 | xy,"exclusive or with long offset",implemented, |
| 583 | icy,"insert character with long offset",implemented, |
| 584 | icmy,"insert characters with long offset",implemented, |
| 585 | ldy,"load (long) with long offset",implemented, |
| 586 | ley,"load (short) with long offset",implemented, |
| 587 | ly,"load with long offset",implemented, |
| 588 | lamy,"load access multiple",implemented, |
| 589 | lay,"load address with long offset",implemented, |
| 590 | lb,"load byte with long offset",implemented, |
| 591 | lgb,"load byte with long offset 64",implemented, |
| 592 | lhy,"load halfword with long offset",implemented, |
| 593 | lmy,"load multiple with long offset",implemented, |
| 594 | lray,"load real address with long offset",N/A,"privileged instruction" |
| 595 | mviy,"move immediate with long offset",implemented, |
| 596 | msy,"multiply single with long offset",implemented, |
| 597 | oiy,"or immediate with long offset",implemented, |
| 598 | oy,"or with long offset",implemented, |
| 599 | stdy,"store (long) with long offset",implemented, |
| 600 | stey,"store (short) with long offset",implemented, |
| 601 | sty,"store with long offset",implemented, |
| 602 | stamy,"store access multiple with long offset",implemented, |
| 603 | stcy,"store character with long offset",implemented, |
| 604 | stcmy,"store characters under mask with long offset",implemented, |
| 605 | sthy,"store halfword with long offset",implemented, |
| 606 | stmy,"store multiple with long offset",implemented, |
| 607 | sy,"subtract with long offset",implemented, |
| 608 | shy,"subtract halfword with long offset",implemented, |
| 609 | sly,"subtract logical with long offset",implemented, |
| 610 | tmy,"test under mask with long offset",implemented, |
| 611 | clclu,"compare logical long unicode with long offset","not implemented", |
| 612 | cspg,"compare and swap and purge",N/A,"privileged instruction" |
| 613 | idte,"invalidate dat table entry",N/A,"privileged instruction" |
| 614 | madr,"multiply and add long hfp","won't do","hfp instruction" |
| 615 | mad,"multiply and add long hfp","won't do","hfp instruction" |
| 616 | maer,"multiply and add short hfp","won't do","hfp instruction" |
| 617 | mae,"multiply and add short hfp","won't do","hfp instruction" |
| 618 | msdr,"multiply and subtract long hfp","won't do","hfp instruction" |
| 619 | msd,"multiply and subtract long hfp","won't do","hfp instruction" |
| 620 | mser,"mutliply and subtract short hfp","won't do","hfp instruction" |
| 621 | mse,"multiply and subttract short hfp","won't do","hfp instruction" |
| 622 | km,"cipher message","not implemented", |
| 623 | kmc,"cipher message with chaining","not implemented", |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 624 | kmf,"cipher message with CFB","not implemented", |
| 625 | kmo,"cipher message with OFB","not implemented", |
| 626 | kmctr,"cipher message with counter","not implemented", |
| 627 | pcc,"perform cryptographic computation","not implemented", |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 628 | kimd,"compute intermediate message digest","not implemented", |
| 629 | klmd,"compute last message digest","not implemented", |
| 630 | kmac,"compute message authentication code","not implemented", |
| 631 | afi,"add immediate 32",implemented, |
| 632 | agfi,"add immediate 64<32",implemented, |
| 633 | alfi,"add logical immediate 32",implemented, |
| 634 | algfi,"add logical immediate 64<32",implemented, |
| 635 | nihf,"and immediate high",implemented, |
| 636 | nilf,"and immediate low",implemented, |
| 637 | cfi,"compare immediate 32",implemented, |
| 638 | cgfi,"compare immediate 64<32",implemented, |
| 639 | clfi,"compare logical immediate 32",implemented, |
| 640 | clgfi,"compare logical immediate 64<32",implemented, |
| 641 | xihf,"exclusive or immediate high",implemented, |
| 642 | xilf,"exclusive or immediate low",implemented, |
| 643 | iihf,"insert immediate high",implemented, |
| 644 | iilf,"insert immediate low",implemented, |
| 645 | flogr,"find leftmost one",implemented, |
| 646 | lt,"load and test 32",implemented, |
| 647 | ltg,"load and test 64",implemented, |
| 648 | lbr,"load byte 32",implemented, |
| 649 | lgbr,"load byte 64",implemented, |
| 650 | lhr,"load halfword 32",implemented, |
| 651 | lghr,"load halfword 64",implemented, |
| 652 | lgfi,"load immediate 64<32",implemented, |
| 653 | llc,"load logical character 32",implemented, |
| 654 | llcr,"load logical character 32",implemented, |
| 655 | llgcr,"load logical character 64",implemented, |
| 656 | llh,"load logical halfword 32",implemented, |
| 657 | llhr,"load logical halfword 32",implemented, |
| 658 | llghr,"load logical halfword 64",implemented, |
| 659 | llihf,"load logical immediate high",implemented, |
| 660 | llilf,"load logical immediate low",implemented, |
| 661 | oihf,"or immediate high",implemented, |
| 662 | oilf,"or immediate low",implemented, |
| 663 | slfi,"subtract logical immediate 32",implemented, |
| 664 | slgfi,"subtract logical immediate 64<32",implemented, |
| 665 | ptff,"perform timing facility function",N/A,"privileged instruction" |
| 666 | stfle,"store facility list extended",implemented, |
| 667 | stckf,"store clock fast",implemented, |
| 668 | mvcos,"move with optional specifications",N/A,"privileged instruction" |
| 669 | lptea,"load page-table-entry address",N/A,"privileged instruction" |
florian | 9b1de1f | 2012-09-03 15:39:19 +0000 | [diff] [blame] | 670 | cu24,"convert utf-16 to utf-32",implemented, |
| 671 | cu21,"convert utf-16 to utf-8",implemented, |
| 672 | cu42,"convert utf-32 to utf-16",implemented, |
| 673 | cu41,"convert utf-32 to utf-8",implemented, |
| 674 | cu12,"convert utf-8 to utf-16",implemented, |
| 675 | cu14,"convert utf-8 to utf-32",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 676 | srstu,"search string unicode","not implemented", |
| 677 | trtr,"tranlate and test reverse","not implemented", |
| 678 | myr,"multiply unnormalized long hfp","won't do","hfp instruction" |
| 679 | myhr,"multiply unnormalized long hfp high","won't do","hfp instruction" |
| 680 | mylr,"multiply unnormalized long hfp low","won't do","hfp instruction" |
| 681 | my,"multiply unnormalized long hfp","won't do","hfp instruction" |
| 682 | myh,"multiply unnormalized long hfp high","won't do","hfp instruction" |
| 683 | myl,"multiply unnormalized long hfp low","won't do","hfp instruction" |
| 684 | mayr,"multiply and add unnormalized long hfp","won't do","hfp instruction" |
| 685 | mayhr,"multiply and add unnormalized long hfp high","won't do","hfp instruction" |
| 686 | maylr,"multiply and add unnormalized long hfp low","won't do","hfp instruction" |
| 687 | may,"multiply and add unnormalized long hfp","won't do","hfp instruction" |
| 688 | mayh,"multiply and add unnormalized long hfp high","won't do","hfp instruction" |
| 689 | mayl,"multiply and add unnormalized long hfp low","won't do","hfp instruction" |
| 690 | lpdfr,"load positive no cc",implemented, |
| 691 | lndfr,"load negative no cc",implemented, |
| 692 | cpsdr,"copy sign",implemented, |
| 693 | lcdfr,"load complement no cc",implemented, |
| 694 | ldgr,"load fpr from gr",implemented, |
| 695 | lgdr,"load gr from fpr",implemented, |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 696 | cdtr,"compare long dfp",implemented |
| 697 | cxtr,"compare extended dfp",implemented |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 698 | kdtr,"compare and signal long dfp","not implemented", |
| 699 | kxtr,"compare and signal extended dfp","not implemented", |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 700 | cedtr,"compare exponent long dfp",implemented |
| 701 | cextr,"compare exponent extended dfp",implemented |
| 702 | cxgtr,"convert from fixed extended dfp",implemented |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 703 | cdstr,"convert from signed bcd long dfp","not implemented", |
| 704 | cxstr,"convert from signed bcd extended dfp","not implemented", |
| 705 | cdutr,"convert from unsigned bcd to long dfp","not implemented", |
| 706 | cxutr,"convert from unsigned bcd to extended dfp","not implemented", |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 707 | cgdtr,"convert from long dfp to fixed",implemented |
| 708 | cgxtr,"convert from extended dfp to fixed",implemented |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 709 | csdtr,"convert from long dfp to signed bcd","not implemented", |
| 710 | csxtr,"convert from extended dfp to signed bcd","not implemented", |
| 711 | cudtr,"convert from long dfp to unsigned bcd","not implemented", |
| 712 | cuxtr,"convert from extended dfp to unsigned bcd","not implemented", |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 713 | eedtr,"extract biased exponent from long dfp",implemented |
| 714 | eextr,"extract biased exponent from extended dfp",implemented |
| 715 | esdtr,"extract significance from long dfp",implemented |
| 716 | esxtr,"extract significance from extended dfp",implemented |
| 717 | iedtr,"insert biased exponent long dfp",implemented |
| 718 | iextr,"insert biased exponent extended dfp",implemented |
| 719 | ltdtr,"load and test long dfp",implemented |
| 720 | ltxtr,"load and test extended dfp",implemented |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 721 | fidtr,"load fp integer long dfp","not implemented", |
| 722 | fixtr,"load fp integer extended dfp","not implemented", |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 723 | lfas,"load fpc and signal","not implemented", |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 724 | ldetr,"load lengthened long dfp",implemented |
| 725 | lxdtr,"load lengthened extended dfp",implemented |
| 726 | ledtr,"load rounded long dfp",implemented |
| 727 | ldxtr,"load rounded extended dfp",implemented |
| 728 | qadtr,"Quantize long dfp",implemented |
| 729 | qaxtr,"Quantize extended dfp",implemented |
| 730 | rrdtr,"Reround long dfp",implemented |
| 731 | rrxtr,"Reround extended dfp",implemented |
| 732 | srnmt,"set rounding mode dfp",implemented |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 733 | sfasr,"set fpc and signal","not implemented", |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 734 | sldt,"shift coefficient left long dfp",implemented |
| 735 | slxt,"shift coefficient left extended dfp",implemented |
| 736 | srdt,"shift coefficient right long dfp",implemented |
| 737 | srxt,"shift coefficient right extended dfp",implemented |
| 738 | tdcet,"test data class short dfp",implemented |
| 739 | tdcdt,"test data class long dfp",implemented |
| 740 | tdcxt,"test data class extended dfp",implemented |
| 741 | tdget,"test data group short dfp",implemented |
| 742 | tdgdt,"test data group long dfp",implemented |
| 743 | tdgxt,"test data group extended dfp",implemented |
| 744 | pfpo,"perform floating point operation",implemented |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 745 | ectg,"extract cpu time","not implemented", |
| 746 | csst,"compare and swap and store","not implemented", |
| 747 | asi,"add immediate (32<8)",implemented, |
| 748 | agsi,"add immediate (64<8)",implemented, |
| 749 | alsi,"add logical with signed immediate (32<8)",implemented, |
| 750 | algsi,"add logical with signed immediate (64<8)",implemented, |
| 751 | crl,"compare relative long (32)",implemented, |
| 752 | cgrl,"compare relative long (64)",implemented, |
| 753 | cgfrl,"compare relative long (64<32)",implemented, |
| 754 | crb,"compare and branch (32)",implemented, |
| 755 | cgrb,"compare and branch (64)",implemented, |
| 756 | crj,"compare and branch relative (32)",implemented, |
| 757 | cgrj,"compare and branch relative (64)",implemented, |
| 758 | cib,"compare immediate and branch (32<8)",implemented, |
| 759 | cgib,"compare immediate and branch (64<8)",implemented, |
| 760 | cij,"compare immediate and branch relative (32<8)",implemented, |
| 761 | cgij,"compare immediate and branch relative (64<8)",implemented, |
| 762 | crt,"compare and trap","not implemented","issued by gcc" |
| 763 | cgrt,"compare and trap 64","not implemented","issued by gcc" |
| 764 | cit,"compare immediate and trap (32<16)","not implemented","issued by gcc" |
| 765 | cgit,"compare immediate and trap (64<16)","not implemented","issued by gcc" |
| 766 | cgh,"compare halfword (64<16)",implemented, |
| 767 | chhsi,"compare halfword immediate (16<16)",implemented, |
| 768 | chsi,"compare halfword immediate (32<16)",implemented, |
| 769 | cghsi,"compare halfword immediate (64<16)",implemented, |
| 770 | chrl,"compare halfword relative long (32<8)",implemented, |
| 771 | cghrl,"compare halfword relative long (64<8)",implemented, |
| 772 | clhhsi,"compare logical immediate (16<16)",implemented, |
| 773 | clfhsi,"compare logical immediate (32<16)",implemented, |
| 774 | clghsi,"compare logical immediate (64<16)",implemented, |
| 775 | clrl,"compare logical relative long (32)",implemented, |
| 776 | clgrl,"compare logical relative long (64)",implemented, |
| 777 | clgfrl,"compare logical relative long (64<32)",implemented, |
| 778 | clhrl,"compare logical relative long (32<16)",implemented, |
| 779 | clghrl,"compare logical relative long (64<16)",implemented, |
| 780 | clrb,"compare logical and branch (32)",implemented, |
| 781 | clgrb,"compare logical and branch (64)",implemented, |
| 782 | clrj,"compare logical and branch relative (32)",implemented, |
| 783 | clgrj,"compare logical and branch relative (64)",implemented, |
| 784 | clib,"compare logical immediate and branch (32<8)",implemented, |
| 785 | clgib,"compare logical immediate and branch (64<8)",implemented, |
| 786 | clij,"compare logical immediate and branch relative (32<8)",implemented, |
| 787 | clgij,"compare logical immediate and branch relative (64<8)",implemented, |
| 788 | clrt,"compare logical and trap (32)","not implemented", |
| 789 | clgrt,"compare logical and trap (64)","not implemented", |
| 790 | clfit,"compare logical and trap (32<16)","not implemented", |
| 791 | clgit,"compare logical and trap (64<16)","not implemented", |
florian | 4d14968 | 2012-08-26 19:05:06 +0000 | [diff] [blame] | 792 | ecag,"extract cache attribute",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 793 | lrl,"load relative long (32)",implemented, |
| 794 | lgrl,"load relative long (64)",implemented, |
| 795 | lgfrl,"load relative long (64<32)",implemented, |
| 796 | laey,"load address extended",implemented, |
| 797 | ltgf,"load and test (64<32)",implemented, |
| 798 | lhrl,"load halfword relative long (32<16)",implemented, |
| 799 | lghrl,"load halfword relative long (64<16)",implemented, |
| 800 | llgfrl,"load logical relative long (64<32)",implemented, |
| 801 | llhrl,"load logical halfword relative long (32<16)",implemented, |
| 802 | llghrl,"load logical halfword relative long (64<16)",implemented, |
| 803 | mvhhi,"move (16<16)",implemented, |
| 804 | mvhi,"move (32<16)",implemented, |
| 805 | mvghi,"move (64<16)",implemented, |
| 806 | mfy,multiply,implemented, |
| 807 | mhy,"multiply halfword",implemented, |
| 808 | msfi,"multiply single immediate (32)",implemented, |
| 809 | msgfi,"multiply single immediate (64)",implemented, |
| 810 | pfd,"prefetch data",implemented, |
| 811 | pfdrl,"prefetch data relative long",implemented, |
| 812 | rnsbg,"rotate then and selected bits",implemented, |
| 813 | rxsbg,"rotate then exclusive or selected bits",implemented, |
| 814 | rosbg,"rotate then or selected bits",implemented, |
| 815 | risbg,"rotate then insert selected bits",implemented, |
| 816 | strl,"store relative long (32)",implemented, |
| 817 | stgrl,"store relative long (64)",implemented, |
| 818 | sthrl,"store halfword relative long",implemented, |
| 819 | exrl,"execute relative long",implemented, |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 820 | ptf,"perform topology function",N/A,"privileged instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 821 | pfmf,"perform frame management function",N/A,"privileged instruction" |
| 822 | trte,"translate and test extended","not implemented", |
| 823 | trtre,"translate and test reverse extended","not implemented", |
| 824 | ecpga,"extract coprocessor-group address",N/A,"privileged instruction" |
| 825 | ecctr,"extract cpu counter",N/A,"privileged instruction" |
| 826 | epctr,"extract peripheral counter",N/A,"privileged instruction" |
| 827 | lcctl,"load cpu-counter-set controls",N/A,"privileged instruction" |
| 828 | lpctl,"load peripheral-counter-set controls",N/A,"privileged instruction" |
| 829 | lsctl,"load sampling controls",N/A,"privileged instruction" |
| 830 | qctri,"query counter information",N/A,"privileged instruction" |
| 831 | qsi,"query sampling information",N/A,"privileged instruction" |
| 832 | scctr,"set cpu counter",N/A,"privileged instruction" |
| 833 | spctr,"set peripheral counter",N/A,"privileged instruction" |
| 834 | lpp,"load program parameter",N/A,"privileged instruction" |
florian | bd61232 | 2012-12-06 05:04:35 +0000 | [diff] [blame] | 835 | pckmo,"perform cryptographic key management operation",N/A,"privileged instruction" |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 836 | ahhhr,"add high high",implemented, |
| 837 | ahhlr,"add high low",implemented, |
| 838 | aih,"add immediate high",implemented, |
| 839 | alhhhr,"add logical high high",implemented, |
| 840 | alhhlr,"add logical high low",implemented, |
| 841 | alsih,"add logical with signed immediate high with cc",implemented, |
| 842 | alsihn,"add logical with signed immediate high no cc",implemented, |
| 843 | brcth,"branch relative on count high","not implemented", |
| 844 | chhr,"compare high high",implemented, |
| 845 | chlr,"compare high low",implemented, |
| 846 | chf,"compare high",implemented, |
| 847 | cih,"compare immediate high",implemented, |
| 848 | clhhr,"compare logical high high",implemented, |
| 849 | clhlr,"compare logical high low",implemented, |
| 850 | clhf,"compare logical high",implemented, |
| 851 | clih,"compare logical immediate",implemented, |
| 852 | lbh,"load byte high",implemented, |
| 853 | lhh,"load halfword high",implemented, |
| 854 | lfh,"load high",implemented, |
| 855 | llch,"load logical character high",implemented, |
| 856 | llhh,"load logical halfword high",implemented, |
| 857 | risbhg,"rotate then insert selected bits high","not implemented", |
| 858 | risblg,"rotate then insert selected bits low","not implemented", |
| 859 | stch,"store character high",implemented, |
| 860 | sthh,"store halfword high",implemented, |
| 861 | stfh,"store high",implemented, |
| 862 | shhhr,"subtract high high",implemented, |
| 863 | shhlr,"subtract high low",implemented, |
| 864 | slhhhr,"subtract logical high high",implemented, |
| 865 | slhhlr,"subtract logical high low",implemented, |
florian | 5afd53f | 2012-12-02 21:34:57 +0000 | [diff] [blame] | 866 | laa,"load and add 32 bit",implemented, |
| 867 | laag,"load and add 64 bit",implemented, |
| 868 | laal,"load and add logical 32 bit",implemented, |
| 869 | laalg,"load and add logical 64 bit",implemented, |
| 870 | lan,"load and and 32 bit",implemented, |
| 871 | lang,"load and and 64 bit",implemented, |
| 872 | lax,"load and exclusive or 32 bit",implemented, |
| 873 | laxg,"load and exclusive or 64 bit",implemented, |
| 874 | lao,"load and or 32 bit",implemented, |
| 875 | laog,"load and or 64 bit",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 876 | lpd,"load pair disjoint 32 bit","not implemented", |
| 877 | lpdg,"load pair disjoint 64 bit","not implemented", |
| 878 | locr,"load on condition 32 bit",implemented, |
| 879 | locgr,"load on condition 64 bit",implemented, |
| 880 | loc,"load on condition 32 bit",implemented, |
| 881 | locg,"load on condition 64 bit",implemented, |
| 882 | stoc,"store on condition 32 bit",implemented, |
| 883 | stocg,"store on condition 64 bit",implemented, |
| 884 | ark,"add 3 operands 32 bit",implemented, |
| 885 | agrk,"add 3 operands 64 bit",implemented, |
| 886 | ahik,"add immediate 3 operands 32 bit",implemented, |
| 887 | aghik,"add immediate 3 operands 64 bit",implemented, |
| 888 | alrk,"add logical 3 operands 32 bit",implemented, |
| 889 | algrk,"add logical 3 operands 64 bit",implemented, |
| 890 | alhsik,"add logical immediate 3 operands 32 bit",implemented, |
| 891 | alghsik,"add logical immediate 3 operands 64 bit",implemented, |
| 892 | nrk,"and 3 operands 32 bit",implemented, |
| 893 | ngrk,"and 3 operands 64 bit",implemented, |
| 894 | xrk,"xor 3 operands 32 bit",implemented, |
| 895 | xgrk,"xor 3 operands 64 bit",implemented, |
| 896 | ork,"or 3 operands 32 bit",implemented, |
| 897 | ogrk,"or 3 operands 64 bit",implemented, |
| 898 | slak,"shift left single 3 operands 32 bit",implemented, |
| 899 | sllk,"shift left single logical 3 operands 32 bit",implemented, |
| 900 | srak,"shift right single 3 operands 32 bit",implemented, |
| 901 | srlk,"shift right single logical 3 operands 32 bit",implemented, |
| 902 | srk,"subtract 3 operands 32 bit",implemented, |
| 903 | sgrk,"subtract 3 operands 64 bit",implemented, |
| 904 | slrk,"subtract logical 3 operands 32 bit",implemented, |
| 905 | slgrk,"subtract logical 3 operands 64 bit",implemented, |
| 906 | popcnt,"population count","not implemented", |
| 907 | rrbm,"reset reference bits multiple",N/A,"privileged instruction" |
florian | af97692 | 2012-09-02 18:10:34 +0000 | [diff] [blame] | 908 | cefbra,"convert from 32 bit fixed to short bfp with rounding mode",implemented, |
| 909 | cdfbra,"convert from 32 bit fixed to long bfp with rounding mode",implemented, |
| 910 | cxfbra,"convert from 32 bit fixed to extended bfp with rounding mode",implemented, |
| 911 | cegbra,"convert from 64 bit fixed to short bfp with rounding mode",implemented, |
| 912 | cdgbra,"convert from 64 bit fixed to long bfp with rounding mode",implemented, |
| 913 | cxgbra,"convert from 64 bit fixed to extended bfp with rounding mode",implemented, |
florian | 1b9609a | 2012-09-01 00:15:45 +0000 | [diff] [blame] | 914 | celfbr,"convert from 32 bit logical fixed to short bfp with rounding mode",implemented, |
| 915 | cdlfbr,"convert from 32 bit logical fixed to long bfp with rounding mode",implemented, |
| 916 | cxlfbr,"convert from 32 bit logical fixed to extended bfp with rounding mode",implemented, |
| 917 | celgbr,"convert from 64 bit logical fixed to short bfp with rounding mode",implemented, |
| 918 | cdlgbr,"convert from 64 bit logical fixed to long bfp with rounding mode",implemented, |
| 919 | cxlgbr,"convert from 64 bit logical fixed to extended bfp with rounding mode",implemented, |
florian | af97692 | 2012-09-02 18:10:34 +0000 | [diff] [blame] | 920 | cfebra,"convert to 32 bit fixed from short bfp with rounding mode",implemented, |
| 921 | cfdbra,"convert to 32 bit fixed from long bfp with rounding mode",implemented, |
| 922 | cfxbra,"convert to 32 bit fixed from extended bfp with rounding mode",implemented, |
| 923 | cgebra,"convert to 64 bit fixed from short bfp with rounding mode",implemented, |
| 924 | cgdbra,"convert to 64 bit fixed from long bfp with rounding mode",implemented, |
florian | 9b1de1f | 2012-09-03 15:39:19 +0000 | [diff] [blame] | 925 | cgxbra,"convert to 64 bit fixed from extended bfp with rounding mode",implemented, |
florian | 1b9609a | 2012-09-01 00:15:45 +0000 | [diff] [blame] | 926 | clfebr,"convert to 32 bit fixed logical from short bfp with rounding mode",implemented, |
florian | 9b1de1f | 2012-09-03 15:39:19 +0000 | [diff] [blame] | 927 | clfdbr,"convert to 32 bit fixed logical from long bfp with rounding mode",implemented, |
| 928 | clfxbr,"convert to 32 bit fixed logical from extended bfp with rounding mode",implemented, |
| 929 | clgebr,"convert to 64 bit fixed logical from short bfp with rounding mode",implemented, |
| 930 | clgdbr,"convert to 64 bit fixed logical from long bfp with rounding mode",implemented, |
| 931 | clgxbr,"convert to 64 bit fixed logical from extended bfp with rounding mode",implemented, |
florian | eadfb1f | 2012-03-18 01:51:12 +0000 | [diff] [blame] | 932 | fiebra,"load fp integer short bfp with rounding mode","not implemented","new to z196" |
| 933 | fidbra,"load fp integer long bfp with rounding mode","not implemented","new to z196" |
| 934 | fixbra,"load fp integer extended bfp with rounding mode","not implemented","new to z196" |
florian | af97692 | 2012-09-02 18:10:34 +0000 | [diff] [blame] | 935 | ledbra,"load rounded short/long bfp to short/long bfp with rounding mode",implemented, |
florian | 9b1de1f | 2012-09-03 15:39:19 +0000 | [diff] [blame] | 936 | ldxbra,"load rounded long/extended bfp to long/extended bfp with rounding mode",implemented, |
| 937 | lexbra,"load rounded short/extended bfp to short/extended bfp with rounding mode",implemented, |
florian | 0acaac3 | 2013-07-28 16:19:34 +0000 | [diff] [blame] | 938 | adtra,"add long dfp with rounding mode",implemented |
| 939 | axtra,"add extended dfp with rounding mode",implemented |
| 940 | cdgtra,"convert from fixed long dfp with rounding mode",implemented |
| 941 | cdftr,"convert from 32 bit fixed to long dfp with rounding mode",implemented |
| 942 | cxftr,"convert from 32 bit fixed to extended dfp with rounding mode",implemented |
| 943 | cdlgtr,"convert from 64 bit fixed logical to long dfp with rounding mode",implemented |
| 944 | cxlgtr,"convert from 64 bit fixed logical to extended dfp with rounding mode",implemented |
| 945 | cdlftr,"convert from 32 bit fixed logical to long dfp with rounding mode",implemented |
| 946 | cxlftr,"convert from 32 bit fixed logical to extended dfp with rounding mode",implemented |
| 947 | cfdtr,"convert to 32 bit fixed from long dfp source with rounding mode",implemented |
| 948 | cfxtr,"convert to 32 bit fixed from extended dfp source with rounding mode",implemented |
| 949 | clgdtr,"convert to 64 bit fixed logical from long dfp with rounding mode",implemented |
| 950 | clgxtr,"convert to 64 bit fixed logical from extended dfp with rounding mode",implemented |
| 951 | clfdtr,"convert to 32 bit fixed logical from long dfp with rounding mode",implemented |
| 952 | clfxtr,"convert to 32 bit fixed logical from extended dfp with rounding mode",implemented |
| 953 | ddtra,"divide long dfp with rounding mode",implemented |
| 954 | dxtra,"divide extended dfp with rounding mode",implemented |
| 955 | mdtra,"multiply long dfp with rounding mode",implemented |
| 956 | mxtra,"multiply extended dfp with rounding mode",implemented |
| 957 | sdtra,"subtract long dfp with rounding mode",implemented |
| 958 | sxtra,"subtract extended dfp with rounding mode",implemented |
florian | 4d87b8a | 2012-09-18 20:25:23 +0000 | [diff] [blame] | 959 | srnmb,"set 3 bit bfp rounding mode",implemented, |
florian | 384176b | 2012-12-05 04:21:41 +0000 | [diff] [blame] | 960 | etnd,"extract transaction nesting depth","not implemented",zEC12, |
| 961 | ntstg,"nontransactional store","not implemented",zEC12, |
| 962 | tabort,"transaction abort","not implemented",zEC12, |
| 963 | tbegin,"transaction begin","not implemented",zEC12, |
| 964 | tbeginc,"constrained transaction begin","not implemented",zEC12, |
| 965 | tend,"transaction end","not implemented",zEC12, |
| 966 | bpp,"branch prediction preload","not implemented",zEC12, |
| 967 | bprp,"branch prediction relative preload","not implemented",zEC12, |
| 968 | ppa,"perform processor assist","not implemented",zEC12, |
| 969 | niai,"next instruction access intent","not implemented",zEC12, |
| 970 | crdte,"compare and replace DAT table entry",N/A,"privileged instruction" |
| 971 | lat,"load and trap 32 bit","not implemented",zEC12, |
| 972 | lgat,"load and trap 64 bit","not implemented",zEC12, |
| 973 | lfhat,"load high and trap","not implemented",zEC12, |
| 974 | llgfat,"load logical and trap 32>64","not implemented",zEC12, |
| 975 | llgtat,"load logical thirty one bits and trap 31>64","not implemented",zEC12, |
| 976 | clt,"compare logical and trap 32 bit reg-mem","not implemented",zEC12, |
| 977 | clgt,"compare logical and trap 64 bit reg-mem","not implemented",zEC12, |
| 978 | risbgn,"rotate then insert selected bits nocc","not implemented",zEC12, |
| 979 | cdzt,"convert from zoned long","not implemented",zEC12, |
| 980 | cxzt,"convert from zoned extended","not implemented",zEC12, |
| 981 | czdt,"convert to zoned long","not implemented",zEC12, |
| 982 | czxt,"convert to zoned extended","not implemented",zEC12, |