Lines Matching defs:instr
83 int FormatFPRegister(Instruction* instr, const char* format);
84 int FormatVectorRegister(Instruction* instr, const char* format);
89 int FormatRegister(Instruction* instr, const char* option);
90 int FormatOption(Instruction* instr, const char* option);
91 void Format(Instruction* instr, const char* format);
92 void Unknown(Instruction* instr);
93 void UnknownFormat(Instruction* instr, const char* opcname);
95 void DecodeExtP(Instruction* instr);
96 void DecodeExt0(Instruction* instr);
97 void DecodeExt1(Instruction* instr);
98 void DecodeExt2(Instruction* instr);
99 void DecodeExt3(Instruction* instr);
100 void DecodeExt4(Instruction* instr);
101 void DecodeExt5(Instruction* instr);
102 void DecodeExt6(Instruction* instr);
185 int Decoder::FormatRegister(Instruction* instr, const char* format) {
189 int reg = instr->RTValue();
193 int reg = instr->RAValue();
197 int reg = instr->RBValue();
207 int Decoder::FormatFPRegister(Instruction* instr, const char* format) {
213 reg = instr->RTValue();
215 reg = instr->RAValue();
217 reg = instr->RBValue();
219 reg = instr->RCValue();
229 int Decoder::FormatVectorRegister(Instruction* instr, const char* format) {
233 reg = instr->RTValue();
235 reg = instr->RAValue();
237 reg = instr->RBValue();
239 reg = instr->RCValue();
254 int Decoder::FormatOption(Instruction* instr, const char* format) {
257 if (instr->Bit(10) == 1) {
263 if (instr->Bit(0) == 1) {
271 return FormatRegister(instr, format);
274 return FormatFPRegister(instr, format);
278 if (instr->Bit(0) == 1) {
279 return FormatVectorRegister(instr, format);
282 return FormatFPRegister(instr, format);
285 return FormatVectorRegister(instr, format);
289 uint32_t imm_value = instr->Bits(15, 0);
301 int8_t value = instr->Bits(18, 11);
307 int32_t value = instr->Bits(15, 0);
313 uint8_t value = instr->Bits(19, 12);
319 int32_t value = static_cast<int32_t>(SIGN_EXT_IMM5(instr->Bits(20, 16)));
325 uint8_t value = instr->Bits(19, 16);
332 if (instr->Bit(0) == 1) {
339 if (instr->Bit(1) == 1) {
345 int code = instr->Bits(20, 18);
356 int off = ((instr->Bits(25, 2)) << 8) >> 6;
359 converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
362 int off = ((instr->Bits(15, 2)) << 18) >> 16;
365 converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
372 int32_t opcode = instr->OpcodeValue() << 26;
373 int32_t sh = instr->Bits(15, 11);
375 (opcode == EXT2 && instr->Bits(10, 2) << 2 == SRADIX)) {
377 value = (sh | (instr->Bit(1) << 5));
389 if (instr->OpcodeValue() << 26 != EXT5) {
391 value = (instr->Bits(10, 6) << 26) >> 26;
394 value = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
397 if (instr->OpcodeValue() << 26 != EXT5) {
399 value = (instr->Bits(5, 1) << 26) >> 26;
402 value = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
414 int32_t value = SIGN_EXT_IMM16(instr->Bits(15, 0) & ~3);
431 void Decoder::Format(Instruction* instr, const char* format) {
435 format += FormatOption(instr, format);
448 Unknown(instr); \
452 // For currently unimplemented decodings the disassembler calls Unknown(instr)
454 void Decoder::Unknown(Instruction* instr) { Format(instr, "unknown"); }
457 // UnknownFormat(instr) which will just print opcode name of the
459 void Decoder::UnknownFormat(Instruction* instr, const char* name) {
462 Format(instr, buffer);
465 void Decoder::DecodeExtP(Instruction* instr) {
466 switch (EXTP | (instr->BitField(25, 25))) {
470 DCHECK_NE(instr->Bit(20), 1);
472 SetAsPrefixed(instr->Bits(17, 0));
475 bit_cast<Instruction*>(bit_cast<intptr_t>(instr) + kInstrSize);
481 Format(instr, "pli");
484 Format(instr, "paddi");
531 Unknown(instr);
537 Unknown(instr);
542 void Decoder::DecodeExt0(Instruction* instr) {
544 switch (EXT0 | (instr->BitField(20, 16)) | (instr->BitField(10, 0))) {
547 Format(instr, #name " 'Vt, 'Vb"); \
554 Format(instr, #name " 'rt, 'Vb"); \
561 switch (EXT0 | (instr->BitField(5, 0))) {
564 Format(instr, #name " 'Vt, 'Va, 'Vb, 'Vc"); \
570 switch (EXT0 | (instr->BitField(9, 0))) {
574 Format(instr, #name " 'Vt, 'Va, 'Vb"); \
580 switch (EXT0 | (instr->BitField(10, 0))) {
583 Format(instr, #name " 'Vt, 'Vb, 'UIM"); \
590 Format(instr, #name " 'Vt, 'Va, 'Vb"); \
597 Format(instr, #name " 'Vt, 'Vb"); \
604 Format(instr, #name " 'Vt, 'SIM"); \
611 Format(instr, #name " 'Vt, 'rb, 'UIM"); \
619 void Decoder::DecodeExt1(Instruction* instr) {
620 switch (EXT1 | (instr->BitField(10, 1))) {
622 UnknownFormat(instr, "mcrf"); // not used by V8
626 int bo = instr->BitField(25, 21);
627 int bi = instr->Bits(20, 16);
631 UnknownFormat(instr, "bclrx-dcbnzf");
635 UnknownFormat(instr, "bclrx-dcbezf");
641 Format(instr, "bnelr'l'cr");
644 Format(instr, "blelr'l'cr");
647 Format(instr, "bgelr'l'cr");
650 Format(instr, "bnsolr'l'cr");
656 UnknownFormat(instr, "bclrx-dcbbzt");
660 UnknownFormat(instr, "bclrx-dcbnezt");
666 Format(instr, "beqlr'l'cr");
669 Format(instr, "bgtlr'l'cr");
672 Format(instr, "bltlr'l'cr");
675 Format(instr, "bsolr'l'cr");
681 UnknownFormat(instr, "bclrx-dcbnz");
685 UnknownFormat(instr, "bclrx-dcbez"); // not used by V8
689 Format(instr, "blr'l");
696 switch (instr->BitField(25, 21)) {
698 UnknownFormat(instr, "bcctrx-dcbnzf");
702 UnknownFormat(instr, "bcctrx-dcbezf");
706 UnknownFormat(instr, "bcctrx-bf");
710 UnknownFormat(instr, "bcctrx-dcbnzt");
714 UnknownFormat(instr, "bcctrx-dcbezf");
718 UnknownFormat(instr, "bcctrx-bt");
722 UnknownFormat(instr, "bcctrx-dcbnz");
726 UnknownFormat(instr, "bcctrx-dcbez");
730 if (instr->Bit(0) == 1) {
731 Format(instr, "bctrl");
733 Format(instr, "bctr");
744 Format(instr, "crnor (stuff)");
748 Format(instr, "rfi (stuff)");
752 Format(instr, "crandc (stuff)");
756 Format(instr, "isync (stuff)");
760 Format(instr, "crxor (stuff)");
764 UnknownFormat(instr, "crnand");
768 UnknownFormat(instr, "crand");
772 UnknownFormat(instr, "creqv");
776 UnknownFormat(instr, "crorc");
780 UnknownFormat(instr, "cror");
784 Unknown(instr); // not used by V8
789 void Decoder::DecodeExt2(Instruction* instr) {
791 switch (EXT2 | (instr->BitField(10, 1))) {
793 Format(instr, "lvx 'Vt, 'ra, 'rb");
797 Format(instr, "stvx 'Vs, 'ra, 'rb");
801 Format(instr, "lxvd 'Xt, 'ra, 'rb");
805 Format(instr, "lxvx 'Xt, 'ra, 'rb");
809 Format(instr, "lxsdx 'Xt, 'ra, 'rb");
813 Format(instr, "lxsibzx 'Xt, 'ra, 'rb");
817 Format(instr, "lxsihzx 'Xt, 'ra, 'rb");
821 Format(instr, "lxsiwzx 'Xt, 'ra, 'rb");
825 Format(instr, "stxvd 'Xs, 'ra, 'rb");
829 Format(instr, "stxvx 'Xs, 'ra, 'rb");
833 Format(instr, "stxsdx 'Xs, 'ra, 'rb");
837 Format(instr, "stxsibx 'Xs, 'ra, 'rb");
841 Format(instr, "stxsihx 'Xs, 'ra, 'rb");
845 Format(instr, "stxsiwx 'Xs, 'ra, 'rb");
849 Format(instr, "srw'. 'ra, 'rs, 'rb");
854 Format(instr, "srd'. 'ra, 'rs, 'rb");
859 Format(instr, "sraw'. 'ra, 'rs, 'rb");
864 Format(instr, "srad'. 'ra, 'rs, 'rb");
869 Format(instr, "sync");
873 Format(instr, "modsw 'rt, 'ra, 'rb");
877 Format(instr, "moduw 'rt, 'ra, 'rb");
882 Format(instr, "modsd 'rt, 'ra, 'rb");
886 Format(instr, "modud 'rt, 'ra, 'rb");
891 Format(instr, "srawi'. 'ra,'rs,'sh");
895 Format(instr, "extsh'. 'ra, 'rs");
900 Format(instr, "extsw'. 'ra, 'rs");
905 Format(instr, "extsb'. 'ra, 'rs");
909 Format(instr, "lfsx 'Dt, 'ra, 'rb");
913 Format(instr, "lfsux 'Dt, 'ra, 'rb");
917 Format(instr, "lfdx 'Dt, 'ra, 'rb");
921 Format(instr, "lfdux 'Dt, 'ra, 'rb");
925 Format(instr, "stfsx 'rs, 'ra, 'rb");
929 Format(instr, "stfsux 'rs, 'ra, 'rb");
933 Format(instr, "stfdx 'rs, 'ra, 'rb");
937 Format(instr, "stfdux 'rs, 'ra, 'rb");
941 Format(instr, "popcntw 'ra, 'rs");
946 Format(instr, "popcntd 'ra, 'rs");
952 switch (EXT2 | (instr->BitField(10, 2))) {
954 Format(instr, "sradi'. 'ra,'rs,'sh");
959 switch (EXT2 | (instr->BitField(10, 0))) {
961 Format(instr, "stbcx 'rs, 'ra, 'rb");
965 Format(instr, "sthcx 'rs, 'ra, 'rb");
969 Format(instr, "stwcx 'rs, 'ra, 'rb");
973 Format(instr, "stdcx 'rs, 'ra, 'rb");
979 switch (EXT2 | (instr->BitField(10, 1))) {
982 if (instr->Bit(21)) {
984 Format(instr, "cmp 'ra, 'rb");
987 Format(instr, "cmpw 'ra, 'rb");
993 Format(instr, "slw'. 'ra, 'rs, 'rb");
998 Format(instr, "sld'. 'ra, 'rs, 'rb");
1003 Format(instr, "subfc'. 'rt, 'ra, 'rb");
1007 Format(instr, "subfe'. 'rt, 'ra, 'rb");
1011 Format(instr, "addc'. 'rt, 'ra, 'rb");
1015 Format(instr, "adde'. 'rt, 'ra, 'rb");
1019 Format(instr, "cntlzw'. 'ra, 'rs");
1023 Format(instr, "cntlzd'. 'ra, 'rs");
1027 Format(instr, "cnttzw'. 'ra, 'rs");
1031 Format(instr, "cnttzd'. 'ra, 'rs");
1035 Format(instr, "brh 'ra, 'rs");
1039 Format(instr, "brw 'ra, 'rs");
1043 Format(instr, "brd 'ra, 'rs");
1047 Format(instr, "and'. 'ra, 'rs, 'rb");
1051 Format(instr, "andc'. 'ra, 'rs, 'rb");
1056 if (instr->Bit(21)) {
1058 Format(instr, "cmpl 'ra, 'rb");
1061 Format(instr, "cmplw 'ra, 'rb");
1067 Format(instr, "neg'. 'rt, 'ra");
1071 Format(instr, "nor'. 'rt, 'ra, 'rb");
1075 Format(instr, "subf'. 'rt, 'ra, 'rb");
1079 Format(instr, "mulhw'o'. 'rt, 'ra, 'rb");
1083 Format(instr, "addze'. 'rt, 'ra");
1087 Format(instr, "mullw'o'. 'rt, 'ra, 'rb");
1092 Format(instr, "mulld'o'. 'rt, 'ra, 'rb");
1097 Format(instr, "divw'o'. 'rt, 'ra, 'rb");
1101 Format(instr, "divwu'o'. 'rt, 'ra, 'rb");
1106 Format(instr, "divd'o'. 'rt, 'ra, 'rb");
1111 Format(instr, "add'o 'rt, 'ra, 'rb");
1115 Format(instr, "xor'. 'ra, 'rs, 'rb");
1119 if (instr->RTValue() == instr->RBValue()) {
1120 Format(instr, "mr 'ra, 'rb");
1122 Format(instr, "or 'ra, 'rs, 'rb");
1127 int spr = instr->Bits(20, 11);
1129 Format(instr, "mflr 'rt");
1131 Format(instr, "mfspr 'rt ??");
1136 int spr = instr->Bits(20, 11);
1138 Format(instr, "mtlr 'rt");
1140 Format(instr, "mtctr 'rt");
1142 Format(instr, "mtspr 'rt ??");
1147 Format(instr, "mfcr 'rt");
1151 Format(instr, "stwx 'rs, 'ra, 'rb");
1155 Format(instr, "stwux 'rs, 'ra, 'rb");
1159 Format(instr, "stbx 'rs, 'ra, 'rb");
1163 Format(instr, "stbux 'rs, 'ra, 'rb");
1167 Format(instr, "sthx 'rs, 'ra, 'rb");
1171 Format(instr, "sthux 'rs, 'ra, 'rb");
1175 Format(instr, "lwzx 'rt, 'ra, 'rb");
1179 Format(instr, "lwzux 'rt, 'ra, 'rb");
1183 Format(instr, "lwax 'rt, 'ra, 'rb");
1187 Format(instr, "lbzx 'rt, 'ra, 'rb");
1191 Format(instr, "lbzux 'rt, 'ra, 'rb");
1195 Format(instr, "lhzx 'rt, 'ra, 'rb");
1199 Format(instr, "lhzux 'rt, 'ra, 'rb");
1203 Format(instr, "lhax 'rt, 'ra, 'rb");
1207 Format(instr, "lbarx 'rt, 'ra, 'rb");
1211 Format(instr, "lharx 'rt, 'ra, 'rb");
1215 Format(instr, "lwarx 'rt, 'ra, 'rb");
1220 Format(instr, "ldx 'rt, 'ra, 'rb");
1224 Format(instr, "ldux 'rt, 'ra, 'rb");
1228 Format(instr, "ldarx 'rt, 'ra, 'rb");
1232 Format(instr, "stdx 'rt, 'ra, 'rb");
1236 Format(instr, "stdux 'rt, 'ra, 'rb");
1240 Format(instr, "mfvsrd 'ra, 'Xs");
1244 Format(instr, "mffprwz 'ra, 'Dt");
1248 Format(instr, "mtvsrd 'Xt, 'ra");
1252 Format(instr, "mtfprwa 'Dt, 'ra");
1256 Format(instr, "mtfprwz 'Dt, 'ra");
1260 Format(instr, "mtvsrdd 'Xt, 'ra, 'rb");
1264 Format(instr, "ldbrx 'rt, 'ra, 'rb");
1268 Format(instr, "lhbrx 'rt, 'ra, 'rb");
1272 Format(instr, "lwbrx 'rt, 'ra, 'rb");
1276 Format(instr, "stdbrx 'rs, 'ra, 'rb");
1280 Format(instr, "stwbrx 'rs, 'ra, 'rb");
1284 Format(instr, "sthbrx 'rs, 'ra, 'rb");
1288 Format(instr, "mtcrf 'FXM, 'rs");
1294 switch (EXT2 | (instr->BitField(5, 1))) {
1296 Format(instr, "isel 'rt, 'ra, 'rb");
1300 Unknown(instr); // not used by V8
1305 void Decoder::DecodeExt3(Instruction* instr) {
1306 switch (EXT3 | (instr->BitField(10, 1))) {
1308 Format(instr, "fcfids'. 'Dt, 'Db");
1312 Format(instr, "fcfidus'.'Dt, 'Db");
1316 Unknown(instr); // not used by V8
1321 void Decoder::DecodeExt4(Instruction* instr) {
1322 switch (EXT4 | (instr->BitField(5, 1))) {
1324 Format(instr, "fdiv'. 'Dt, 'Da, 'Db");
1328 Format(instr, "fsub'. 'Dt, 'Da, 'Db");
1332 Format(instr, "fadd'. 'Dt, 'Da, 'Db");
1336 Format(instr, "fsqrt'. 'Dt, 'Db");
1340 Format(instr, "fsel'. 'Dt, 'Da, 'Dc, 'Db");
1344 Format(instr, "fmul'. 'Dt, 'Da, 'Dc");
1348 Format(instr, "fmsub'. 'Dt, 'Da, 'Dc, 'Db");
1352 Format(instr, "fmadd'. 'Dt, 'Da, 'Dc, 'Db");
1357 switch (EXT4 | (instr->BitField(10, 1))) {
1359 Format(instr, "fcmpu 'Da, 'Db");
1363 Format(instr, "frsp'. 'Dt, 'Db");
1367 Format(instr, "fcfid'. 'Dt, 'Db");
1371 Format(instr, "fcfidu'. 'Dt, 'Db");
1375 Format(instr, "fctid 'Dt, 'Db");
1379 Format(instr, "fctidz 'Dt, 'Db");
1383 Format(instr, "fctidu 'Dt, 'Db");
1387 Format(instr, "fctiduz 'Dt, 'Db");
1391 Format(instr, "fctiw'. 'Dt, 'Db");
1395 Format(instr, "fctiwz'. 'Dt, 'Db");
1399 Format(instr, "fctiwuz 'Dt, 'Db");
1403 Format(instr, "fmr'. 'Dt, 'Db");
1407 Format(instr, "mtfsfi'. ?,?");
1411 Format(instr, "mffs'. 'Dt");
1415 Format(instr, "mtfsf'. 'Db ?,?,?");
1419 Format(instr, "fabs'. 'Dt, 'Db");
1423 Format(instr, "frin. 'Dt, 'Db");
1427 Format(instr, "friz. 'Dt, 'Db");
1431 Format(instr, "frip. 'Dt, 'Db");
1435 Format(instr, "frim. 'Dt, 'Db");
1439 Format(instr, "fneg'. 'Dt, 'Db");
1443 Format(instr, "fcpsgn'. 'Dt, 'Da, 'Db");
1447 Format(instr, "mcrfs ?,?");
1451 Format(instr, "mtfsb0'. ?");
1455 Format(instr, "mtfsb1'. ?");
1459 Unknown(instr); // not used by V8
1464 void Decoder::DecodeExt5(Instruction* instr) {
1465 switch (EXT5 | (instr->BitField(4, 2))) {
1467 Format(instr, "rldicl'. 'ra, 'rs, 'sh, 'mb");
1471 Format(instr, "rldicr'. 'ra, 'rs, 'sh, 'me");
1475 Format(instr, "rldic'. 'ra, 'rs, 'sh, 'mb");
1479 Format(instr, "rldimi'. 'ra, 'rs, 'sh, 'mb");
1483 switch (EXT5 | (instr->BitField(4, 1))) {
1485 Format(instr, "rldcl'. 'ra, 'rs, 'sb, 'mb");
1489 Unknown(instr); // not used by V8
1492 void Decoder::DecodeExt6(Instruction* instr) {
1493 switch (EXT6 | (instr->BitField(10, 1))) {
1495 Format(instr, "xxspltib 'Xt, 'IMM8");
1499 switch (EXT6 | (instr->BitField(10, 3))) {
1502 Format(instr, #name " 'Xt, 'Xa, 'Xb"); \
1509 Format(instr, #name " 'Dt, 'Da, 'Db"); \
1516 switch (EXT6 | (instr->BitField(20, 16)) | (instr->BitField(10, 2))) {
1519 Format(instr, #name " 'Xt, 'Xb"); \
1525 switch (EXT6 | (instr->BitField(10, 2))) {
1528 Format(instr, #name " 'Xt, 'Xb"); \
1535 Format(instr, #name " 'Dt, 'Db"); \
1541 Unknown(instr); // not used by V8
1548 Instruction* instr = Instruction::At(instr_ptr);
1550 uint32_t opcode = instr->OpcodeValue() << 26;
1554 "%08x ", instr->InstructionBits());
1559 bit_cast<Instruction*>(bit_cast<intptr_t>(instr) + kInstrSize);
1562 instr->InstructionBits(), next_instr->InstructionBits());
1565 if (ABI_USES_FUNCTION_DESCRIPTORS && instr->InstructionBits() == 0) {
1568 Format(instr, "constant");
1574 PrintSoftwareInterrupt(instr->SvcValue());
1578 UnknownFormat(instr, "mulli");
1582 Format(instr, "subfic 'rt, 'ra, 'int16");
1587 if (instr->Bit(21)) {
1589 Format(instr, "cmpli 'ra, 'uint16");
1592 Format(instr, "cmplwi 'ra, 'uint16");
1599 if (instr->Bit(21)) {
1601 Format(instr, "cmpi 'ra, 'int16");
1604 Format(instr, "cmpwi 'ra, 'int16");
1610 Format(instr, "addic 'rt, 'ra, 'int16");
1614 UnknownFormat(instr, "addicx");
1618 if (instr->RAValue() == 0) {
1620 Format(instr, "li 'rt, 'int16");
1622 Format(instr, "addi 'rt, 'ra, 'int16");
1627 if (instr->RAValue() == 0) {
1628 Format(instr, "lis 'rt, 'int16");
1630 Format(instr, "addis 'rt, 'ra, 'int16");
1635 int bo = instr->Bits(25, 21) << 21;
1636 int bi = instr->Bits(20, 16);
1642 Format(instr, "beq'l'a'cr 'target16");
1645 Format(instr, "bgt'l'a'cr 'target16");
1648 Format(instr, "blt'l'a'cr 'target16");
1651 Format(instr, "bso'l'a'cr 'target16");
1659 Format(instr, "bne'l'a'cr 'target16");
1662 Format(instr, "ble'l'a'cr 'target16");
1665 Format(instr, "bge'l'a'cr 'target16");
1668 Format(instr, "bnso'l'a'cr 'target16");
1674 Format(instr, "bdnz'l'a 'target16");
1678 Format(instr, "bc'l'a'cr 'target16");
1684 UnknownFormat(instr, "sc");
1688 Format(instr, "b'l'a 'target26");
1692 DecodeExtP(instr);
1696 DecodeExt0(instr);
1700 DecodeExt1(instr);
1704 Format(instr, "rlwimi'. 'ra, 'rs, 'sh, 'me, 'mb");
1708 Format(instr, "rlwinm'. 'ra, 'rs, 'sh, 'me, 'mb");
1712 Format(instr, "rlwnm'. 'ra, 'rs, 'rb, 'me, 'mb");
1716 Format(instr, "ori 'ra, 'rs, 'uint16");
1720 Format(instr, "oris 'ra, 'rs, 'uint16");
1724 Format(instr, "xori 'ra, 'rs, 'uint16");
1728 Format(instr, "xoris 'ra, 'rs, 'uint16");
1732 Format(instr, "andi. 'ra, 'rs, 'uint16");
1736 Format(instr, "andis. 'ra, 'rs, 'uint16");
1740 DecodeExt2(instr);
1744 Format(instr, "lwz 'rt, 'int16('ra)");
1748 Format(instr, "lwzu 'rt, 'int16('ra)");
1752 Format(instr, "lbz 'rt, 'int16('ra)");
1756 Format(instr, "lbzu 'rt, 'int16('ra)");
1760 Format(instr, "stw 'rs, 'int16('ra)");
1764 Format(instr, "stwu 'rs, 'int16('ra)");
1768 Format(instr, "stb 'rs, 'int16('ra)");
1772 Format(instr, "stbu 'rs, 'int16('ra)");
1776 Format(instr, "lhz 'rt, 'int16('ra)");
1780 Format(instr, "lhzu 'rt, 'int16('ra)");
1784 Format(instr, "lha 'rt, 'int16('ra)");
1788 Format(instr, "lhau 'rt, 'int16('ra)");
1792 Format(instr, "sth 'rs, 'int16('ra)");
1796 Format(instr, "sthu 'rs, 'int16('ra)");
1800 UnknownFormat(instr, "lmw");
1804 UnknownFormat(instr, "stmw");
1808 Format(instr, "lfs 'Dt, 'int16('ra)");
1812 Format(instr, "lfsu 'Dt, 'int16('ra)");
1816 Format(instr, "lfd 'Dt, 'int16('ra)");
1820 Format(instr, "lfdu 'Dt, 'int16('ra)");
1824 Format(instr, "stfs 'Dt, 'int16('ra)");
1828 Format(instr, "stfsu 'Dt, 'int16('ra)");
1832 Format(instr, "stfd 'Dt, 'int16('ra)");
1836 Format(instr, "stfdu 'Dt, 'int16('ra)");
1840 DecodeExt3(instr);
1844 DecodeExt4(instr);
1848 DecodeExt5(instr);
1852 DecodeExt6(instr);
1857 switch (instr->Bits(1, 0)) {
1859 Format(instr, "ld 'rt, 'd('ra)");
1862 Format(instr, "ldu 'rt, 'd('ra)");
1865 Format(instr, "lwa 'rt, 'd('ra)");
1871 if (instr->Bit(0) == 0) {
1872 Format(instr, "std 'rs, 'd('ra)");
1874 Format(instr, "stdu 'rs, 'd('ra)");
1880 Unknown(instr);